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

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.

That's strange, is it ever relevant what the license of the language is? It hasn't stopped Linux.

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

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

I think at this point they've moved to just "intercepting" plastic before it makes its way into the ocean. From the parley website:

"In remote areas, we establish systems to intercept plastic waste before it ends up in landfills, gets burned, buried or tossed into rivers or oceans."

So still might be more interesting than the recycled water bottles everyone else is sourcing but maybe disingenuous for them to be using the "ocean plastic" language still.

Then John H. Conway's Surreal Numbers might be of interest to you. Donald Knuth wrote a book about the subject and it's actually in the form of a story with dialogue, not your typical math book. I'll attempt a summary. It is possible to build all number systems at once including all integers, rationals, algebraic, irrational, infinitesimal, hyper-reals and transfinite all at once using a single procedure which resembles Dedekind cuts. From that foundation one can recreate many of the results of non-standard analysis. Conway discovered his Surreal Numbers while investigating Combinatorial Game Theory. He wasn't even trying to create a new foundation for mathematics, he was just playing at his games which many of his colleagues looked down upon as useless. Apparently playing games and having fun can occasionally result in extraordinary discoveries.

Conway's left and right "cuts" look like sets but then again I'm not really sure what they are. Is this alien mathematics accidentally discovered on Earth by perhaps the most intelligent Earthling who ever lived. I don't know. All I can say is I took a detour from my usual math studies to look into Surreal numbers and it was an interesting trip. I'm quite conservative when it comes to math. I don't go around preaching Surreal numbers are the way to do math but it is a curiosity none-the-less worth at least the small price of reading Knuth's short book about it from cover to cover.

If you listen to Conway talk about the Surreals you'll note that he considered it a game (in the game theory sense). He was interested in games of a certain kind and what properties they had, a long the way he stumbled upon this game that we now call the surreal numbers.

I do not understand your question: a set is infinite if and only if there is a bijection between it and one of its strict subsets.

As formal as it gets.

Edit: (not intending to be harsh, just that I probably lack some context to properly understand what you are asking).

Is it point or is it continuous line with infinity as an “end”? And there is infinity elements without any point. Or any section of any one of these baselines (and you can have infinite dimension hence many baselines not just x y z, or r/degree etc) can be remap to itself and hence is infinite as well. The point is not the lines, as mapping proved that the points (said the natural no point) is a smaller subset of the real number or the line.

Just not sure about your point.

This is why math shouldnt be posted on HN.

There is worse misunderstanding/bikeshedding upwards in the thread, although it's more artfully worded. And at least one of the replies to this refers to useful resources. This is, in fact, exactly why math should be posted on HN.

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.

> What is more (conceptually) difficult is concurrency, asynchronous processes etc.

Know any good resources for these?

My own baby, Snigl [0], does always-on cooperative concurrency and asynchronous IO.

Just ask if you need help finding your way around.

https://gitlab.com/sifoo/snigl

Thank you. I’ll check it out over the holidays.

Author here. Definitely agree. The intent was to write the simplest possible to VM that could run real programs. VMs are obviously a deep field of research and there are plenty more projects to learn from.

Thats one of the main reasons i implemented my VM in go.

Its fairly rudimentary, a map for instructions to function pointers but.. I can quickly duplicate a subtree of code and execute it within a different goroutine, and wrap that section of code in an instruction that sets the output to a channel, and have another goroutine select the different channels from different goroutines.

At each node within the tree of code, i store the variables within a map instead of using a stack-based system; if the data is not in the current node, look down the tree until i find it.

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 think we should distinguish between gotos at language level and jumps in the underlying machine code. Djikstra was concerned about correctness at the language level. The whole point is that a structured high level language can provide correctness guarantees which is not present in the underlying machine code, even though all control structures compiles down to jumps.

Gotos are not unavoidable in high level languages.

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

You lost me here. Is this assembler? The question is if and when to use goto in higer-level code, not how to use jumps in machine code, which is a completely different question. What keyword you use for the instruction does not matter.

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/