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

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, info@mydomain.com and user@mydomain.com): 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

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

SELECT is also analogous to normal loops:

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

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 ?

It is highly difficult to synchronize an orchestra without a conductor, that is, some centralization is needed (like CPU clock). Same problem with bands but they tend to use some kind of rhythm generator. It seems that birds have learned how to sing together asynchronously.

This turns out to be a useful way of thinking about alternating current, and you can analyse AC circuits using complex arithmetic in much the same way as you use real algebra to analyse DC circuits.

"Userful way of thinking" and "analyse" something is not a real object strictly speaking - it is a process or phenomenon (no doubt complex numbers are useful here).

But can you say what kind of real object or property a complex number represents or measures? For example, an integer can represent the number of apples and their weight is represented by a real number. What property of a real object can be expressed, for example, as 50i ?

When people say they don't "get" complex numbers, usually they mean they've seen them mentioned, but have never actually done anything with them.

What people complain about is that they do not have a (real or hypothetical) device which can display its measurements as a complex number while they do have devices which measure properties in terms of integer, rational and real numbers.

So what are the complex numbers, really?

If by reality we mean the real world (not mathematics or some abstract model) then the article does not actually answer the question what the complex numbers are really -- they describe what complex numbers mean mathematically (geometrically, algebraically, number theory).

Here are some interpretations of imaginary and real parts in terms of the real (physical) world:

o Time vs. space. This means that they have to be measured using different constituents with different properties. For example, space is reversible and periodic (we can return to the same point where we were before many times while it is not possible to return to previous point in time).

o Periodic vs. monotonic behavior. For example, rotation frequencies or oscillators (electric or physical) vs. linear motion.

I like to think of it as 'outside the current set'.

Yes, if it exists (as an element of some set), then it is definitely outside the declared set of values. The main question is how we can formalize it, particularly, by defining the set NULL is a member of. For example, the following general approaches are possible:

o Extend (any or some) set of values with a special element (NULL)

o NULL = 0 (empty set)

o NULL = <> (empty tuple)

o Treat NULL as non-existence which entails having no-op if it is met, for example, 2 + NULL + 3 = 5 (just delete NULL which means skip it).

SQL's null is a value.

It is known to be one of the major controversies because originally NULL means the absence of a value which entails that it is not a value. Hence, if there are no values, then we cannot do any operations. Yet, for whatever reason (avoiding exceptions etc.) expressions with NULL need to be evaluated and hence NULL is treated as a value. So we get a problem: NULL is not a value AND NULL is a value. There are different views on this problem and the solution implemented in SQL (and three-valued logic) is probably not the best one.

Entropy grows. Quantity of information drops. Interestingness falls. Is not it a natural process?