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.

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).

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

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.