techno_modus

"Remote: Office Not Required", David Heinemeier Hansson, Jason Fried (the authors of ReWork: Change the Way You Work Forever). It is an old book but still very applicable to today (or maybe even more applicable).

I also found this book quite useful:

"REMOTE shows both employers and employees how they can work together, remotely, from any desk, in any space, in any place, anytime, anywhere."

It is not about the language - it is about the interpreter (implementation).

There are many aspects here:

* You simply use it (in interactive mode)

* You integrate it into your application as static lib

* You integrate it into your application as a dynamically linked lib

* You use it via some kind of (remote) API

* Do you integrate via source code, static lib, dynamic lib, API

R is also quite controversial because of its GPL license. I know that there are ways to overcome this issue but most decision makers do not want to risk when they see that a product has such a license.

Adidas is producing millions of its shoes using ocean plastic: https://mymodernmet.com/adidas-parley-sustainable-fashion (and these shoes can be then turned into jet fuel).

It would be interesting to learn about some new (unified) theory that can formalize the notion of infinity. Apparently, this can hardly be done on the basis of the classical (Cartesian) view of space which is essentially a box with points (elements).

Here is another short guide on many useful features of Python 3: https://github.com/arogozhnikov/python3_with_pleasure

Most of the post (~80%) is actually about decision trees: principles, how to train, choosing splits etc.

I like this tutorial but it should be mentioned that before implementing a virtual machine one should understand that there are many computing models and many alternative mechanisms within each of them. Implementing VM for sequential program execution is relatively easy. What is more (conceptually) difficult is concurrency, asynchronous processes etc.

> I think we should distinguish between gotos at language level and jumps in the underlying machine code.

Is there any non-syntactic difference between these two lines?

    JMP Ox1234
    GOTO label_1234

I think they are identical and the question is only where target labels can reside, how they are represented, and when the jumps are triggered (operation).

Jumps to arbitrary instruction addresses (goto) are unavoidable and the dispute is about how to structure such jumps by effectively replacing goto by some other mechanism:

- Introduce scopes and program structure instead of explicit labels (instruction addresses) and using control flow operators which rely on this structure

- Procedures and procedure calls

- Overriding and virtual functions where the system knows how to find the next instruction to jump to

- Concurrency and multi-threading where resume operation means essentially jumping to some (dynamic, not static) instruction address.

- Asynchronous and even-driven programming

Yandex offers an excellent free email service indeed.

What I really like is their free support for custom domains which you need if you later want to move to another email provider later or if you want to create many user email accounts within your domain (say, [email protected] and [email protected]): https://connect.yandex.com/

I personally think first about the loop/iterator organization (FROM in SQL) and only after that what I am going to do with its elements.

However,

    SELECT a1,a2,... FROM Table AS t WHERE Condition

is syntactically equivalent to Python list comprehension:

    [(t.a1,t.a2,...) for t in Table if Condition]

Here the use of attributes (SELECT) is also written before the iterator.

SELECT is also analogous to normal loops:

    foreach t in Table
      if not Condition: continue
      # Use t.a1, t.a2 etc.

Here we first provide the loop specification while the usage of elements is written only in the body.

After reading the section about processors it is not clear whether it can do stateful computations, for example, running sum or moving average. Can I define sliding windows? Can I join two or more streams?

Your room and elephants are different objects. Your room has some size and it is not empty but it has zero elephants or a finite number of zero size elephants.

0 = nothing = non-existence.

> David Hilbert famously argued that infinity cannot exist in physical reality.

This statement reduces the problem to the definitions of "existence" and "physical reality" which of course may have quite different interpretations. For example, the existence of particles (with finite mass and finite coordinates which can be "touched") and the existence of waves are rather different notions.

There have been many critiques of SQL for example: https://sigmodrecord.org/publications/sigmodRecord/1306/pdfs...

> Here, the main difference between flux is that flux has a built-in exponential moving average function, whereas in SQL we have to actually write out the formula.

The possibility to provide arbitrary data processing functions is one of the core features of contemporary query languages. In SQL it has always been a huge problem (and your example is a good demonstration). In the example provided by they also rely on a built-in (exponential smoothing) function and therefore it is not clear whether I can really perform arbitrary ad-hoc computations within the query itself (without built-in or externally defined functions).

Same with "-2 + 2". Maybe it is loading its calculator implementation in JavaScript (including all dependencies).

Michael Stonebraker, Uğur Çetintemel, "One Size Fits All": An Idea Whose Time Has Come and Gone: https://cs.brown.edu/~ugur/fits_all.pdf

What does the property 'contravariant' or 'covariant' belong to: function, functor, class, type class, data type, function or method argument, function or method return value, generic type/collection or something else?

As far as I understand, KSQL is not integral part of Kafka - it is based on Kafka Streams (an independent library). So Kafka is not one system and hence some ambiguity when referring to its functionalities. In particular, "Kafka is as a distributed log" means only Kafka core, not Kafka Streams and KSQL.

How does featuretools compare to tsfresh: https://github.com/blue-yonder/tsfresh ?