hikarudo

The pros and cons of types should always be discussed in the context of type systems. Types exist in a type system.

There are many, many things that can be expressed with types... depending on the type system. In Haskell, when you look at a function type, you instantly know whether it returns an optional value (a Maybe), or if it has side effects (IO), etc. You can also tell how general the function is, by how abstract its parameters are.

An example of something that becomes possible with a rich type system: https://hoogle.haskell.org/

Any insights on why not use conda instead?

Nitpick that doesn't invalidate your question: though the equator line does cross through Brazil, most of the population doesn't live anywhere close to the equator.

Also, Brazil is 4000 kilometers long from north to south.

Same here. I've heard somewhere, in a video about language acquisition, that we have a pattern recognition algorithm in our brains, so all we need is to see examples, and the algorithm does the rest (builds a model by itself).

Wouldn't just LUKS->ZFS be enough?

This sounds super interesting! What do you mean by unsubscribe from routines? Could you give some examples? What effects did doing this have on your life?

I used to think so too. Then I read the research on this, and the evidence suggests the opposite of what you wrote: your time is better spent doing retrieval practice than creating your own cards.

https://www.learningscientists.org/

How are CNNs directly based on FFTs? Sure you can use CNNs with FFT features, but in my experience this is not common.

Unless compression is disabled.

The best descriptors are most certainly obtained with machine learning (embeddings).

I second this. Forget about trading, stock picking, and other wastes of time (and money).

Corporate taxes alone are 34%, one of the highest in the world.

On the topic of the "theory" (mental model) of a program, I recommend John Ousterhout's book "A Philosophy of Software Design". You get such gems as:

"... the greatest limitation in writing software is our ability to understand the systems we are creating."

"Complexity manifests itself in three general ways... change amplification, cognitive load, and unknown unknowns."

"Complexity is caused by two things: dependencies and obscurity."

"Obscurity occurs when important information is not obvious."

"The goal of modular design is to minimize the dependencies between modules."

I would love to have a link to that piece about software reuse in the large vs in the small!

I disagree. The term "edge computing" actually adds precision to a description of a distributed system. Nowadays, with a lot of machine learning inference happening on the cloud, when seeing the term "edge inference" you immediately know you don't have to send heavy bandwidth-clogging video streams to the cloud.

Inference on the edge is a clear trend in computer vision applications, now that we each year there are better low-power neural network accelerators.

"You only look once" in Chinese.

That's a bit weird. Sure it's an advantage if you can optimize the object function more easily. But the end goal is generalization, i.e. performance on new data. The objective function is only a proxy for that.

Knowing how something works is better than not knowing. But you can still have a pretty good idea that it does have the desired effect (i.e. verify cause and effect) via randomized controlled trials.

Of course, alternative medicine proponents rarely do randomized controlled trials.

One thing that is changing quickly: deep learning, particularly inference on the edge. FPGAs are more versatile than ASICs.

Wow, you described my workflow exactly. Using "<" might be shorter and faster-for-the-machine, but it's less readable and breaks the left-to-right order. I also frequently start with `cat x`, see what's in the file, move on to `cat x | some filter` etc.

YOLO will be slow on a raspberry pi. Try instead SSD MobileNetv2 with quantization-aware training and run inference with Tensorflow Lite; you should get at least a few frames per second.

I recommend starting with a pre-trained model (COCO, for instance) and finetuning for your images. However, even with finetuning you probably need > 10k images to get good results.

> (with ML)

Nitpick, that's just camera calibration. No ML needed.

I stand corrected! I shouldn't have guessed "quadratic" without measuring.

Large files will make gcc use more memory, and if you're building on a low-RAW machine, the OS will start to swap. That's probably the effect I saw. Nothing to do with "quadratic" compilation time.

My favorite is simply using a tool to create a C file with your binary data:

  static uint8_t mydata[] = {0xDE, 0xAD, 0xBE, 0xEF, ... };

The advantage is that it works anywhere, with any compiler.

The disadvantage is that it can increase compile time. I would limit each .c file to 10MB; it seems there's a quadratic increase in build time with file size, at least with gcc.

Also, instead of "0x%02x" I use decimal notation and no spaces in order to decrease the .c file size:

  static uint8_t mydata[] = {
  42,7,105,0,0,...,
  8,0,1,20,...,
  ...,
  };

I've often wished for the same thing. I want to know what's wrong about the book before investing time in it.

Spaced practice and retrieval practice, both of which are used in SRS, are two learning techniques for which there is ample evidence that they actually work [0].

Of course, You still need to decide what is worth remembering.

[0] https://www.learningscientists.org/

Absolutely. Keeping it interesting should be one of the first priorities when learning something.

For the record, Anki actually works really well for me. But interest in the subject should come first.

Not original, and I haven't been able to find out the author.

My background was originally in electrical engineering, where this is probably more widely known than in computer science.

"All sensors are temperature sensors."

Even better: use mmap to allocate a virtual huge array, which initially will use no memory at all, and let the OS allocate physical pages to it as needed.