jnxx

I worked for some time at an industrial/embedded company, where in order to build all the software, you had to select "build all" in a menu, and it built everything - more than four million lines of code.

It was a build system which was a pure pleasure to work with, last not least I think because it did not try to solve problems which turn out intractable in the general case.

They are not going to have these supply-chain issues.

> Regulators ultimately approved the plane to return to the air nearly two years after the 2019 crash, but Pierson still doesn’t trust the MAX line — the modernized, *more fuel-efficient version* of Boeing’s predecessor planes.

I think we are witnessing the beginning of the end of the fossil age - and its end will take more than a few companies down with it, which are way too attached to the massive use of fossil fuels.

The majority of accidents happen in the house. That is why one should sleep outside on the pavement ;-)

> Not to mention multiple orders of magnitude safer than driving to the airport.

I guess that's counting accidents per distance. Which is a weird metric if you compare a vehicle that is going some 560 miles per hour with one that is going not even 55 mph on average.

By that metric, using a space shuttle is safer than commuting by bicycle in Europe (which is not only extremely safe if you wear a helmet, cycling will statistically make your life longer instead of shorter, in spite of the accident risk, so large are the health advantages..)

Until Dust Puppy kills 'em

Why does this reminds me in this big, extremely profitable company that made something every American needs in a while, which seems to have abandoned all sanity in their processes? Looks like Intel and Boeing are on a similar path....

> The hyperthread and c-state stuff, eh, if you want to run code that might be a virus you will have to limit your system.

So, you are trusting all web pages you view? Because these are unknown code running on your box which probably has some beefy private data.

I think that a lot of the heat in the debate between different error handling strategies, and whether Exceptions, functional return types, or whatever are the best way, boils down to that there are very, very different requirements.

In some sectors and domains, it is not a problem if a program fails and crashes. And it is also not a problem if a change in error handling makes an internal library backwards-incompatible (*). In such environments, errors are not costly, and it is more important to quickly write code, than that it is always correct. This is even more valid in distributed computing environments which have redundancy.

In other domains, a crash could be deadly (like in an autonomous car) or could cost millions of dollars (like with the Ariane rocket) - and backwards-incompatible changes in libraries might be not tolerable neither (for example, in industrial automation, where core libraries are used for 20+ years).

(*) One point to consider which might not be obvious to most people: When extending a function, which has, say, an enumeration as one argument, it is always possible to extend it by adding new enumeration values to its input parameters, just like one can add keyword arguments with a default value. This modification is always backwards compatible.

But backwards compatibility breaks if one adds enumeration values, or new kinds of errors, or new Exception types to the *output parameters* of a function - because the code of its clients must now be modified to handle all possible cases. If one takes semantic versioning seriously, this is a breaking change. And one can argue that in a statically-typed language used for safety-critical systems, the compiler should always catch that.

> This is the major problem with most comparisons of config file formats: the actual semantic domain of a config file format is extremely limited [ ... ]

So, why not use Scheme ?

That's entirely possible, as speeds are about several thousand meters per second, and differ significantly between several types of waves:

https://en.wikipedia.org/wiki/Seismic_wave

Just a note, there are warning that the earthquake is used to spread disinformation.

Occam and Lisp are both developed from the Lambda calculus and quite close relatives. The main difference is that Lisp is strong-dynamically typed (like Python), and Occam is statically typed (like, say, Java).

> This same phenomenon is the reason why John Ousterhout wrote Tcl and the GNU project started Guile.

Except that Guile is an implementation of Scheme, which is essentially a somewhat minimalist variant of Lisp. So in this case, a real programming language was included intentionally as configuration language.

And this is the same concept as why GNU Emacs is an editor written in Lisp on top of C routines - very similar how data science is often done in Python on top of Numpy and several other packages.

And see GNU Guix, whose configuration is written in Guile Scheme, as a positive example:

https://guix.gnu.org/en/manual/en/html_node/Defining-Package...

> Async Rust is especially problematic in the enterprise world where large software is built out of micro-services connected through RPC.

A weird way to use Rust since you can do a lot of messaging within the process, and use the computing power much more efficiently.

RPC is essentially messaging and message-passing. Message-passing is a way to avoid mutable shared state - this is the model with which Go became successful.

RPC surely has its use but message passing is another, and very often inferior, solution to the problem set where Rust has excellent own solutions for.

> We want to use the whole computer. Code runs on CPUs, and in 2023, even my phone has eight of the damn things. If I want to use more than 12% of the machine, I need several cores.

Isn't that already, in this strong generality, an almost always wrong assumption?

Sure, one can do massively parallel or embarrassingly parallel computation.

Sure, graphic cards are parallel computers.

Sure, OS kernels use multiple cores.

Sure, languages and concepts like Clojure exist and work - for a specific domain, like web services (and for that, Clojure works fascinatingly well).

But there are many, even conceptually simple algorithms which are not easy to parallelize. There is no efficient parallel Fast Fourier Transform I know of.

What about Guix ?

also, peripheral vision is more sensitive to movements/flicker than central vision.

My local food store still give me sticky small olive labels which can be collected in a booklet, which earns an discount once it is full. I love that. And they ask me every time if I want my olives.

That is not necessary any more now.

Now, when there are riots, it is well known that police has human "super-recognizers", which can scan thousands of photos and identify suspect individuals on a whim.

> I pay cash.

Can we, today, be sure that ATMs do not record serial numbers of the bank notes they dispense?

There is actually a lot of research on how catastrophic failures in highly complex systems happen. Here is a brilliant article that summarizes the main findings:

https://how.complexsystems.fail/

I cannot read that one without thinking in the descriptions and analyses of disasters like the sinking of the MS Titanic, the Chernobyl disaster, the loss of the Challenger space shuttle, or the Fukushima disaster. Many, many points in the article seem correct for all of them.

And Guix has put that in an beautiful form. There are two things which make Guix special:

1. The package definitions are just a normal, battle-proven, very well defined general-purpose, functional-style supporting programming language (Scheme).

2. There is no conceptual difference between a package definition in the public Guix system, and a self-written package definition which a developers makes to build and test his own package, or to build and run a specific piece of software. The difference is equally small as between using an Emacs package, and configuring that package in ones .emacs configuration file.

I have been using Python since 25 years, and never needed that one.

Just out of curiosity: Why is it possible to compile Common Lisp Code (or Scheme, or Clojure) to high-performance native or jit-compiled code, but not Python? It is said that "Python is too dynamic", but is not everything in Lisp dynamic, too?

And none of these languages is less powerful than Lisp, lack Unicode support, or whatever, so this can't be the reason.

> Post covid a lot of that got thrown out, commercial buildings are now generally over shooting OA exchange in the name of not turning these spaces into germ breeding grounds.

I think it has become clear that germ loads can be reduced significantly with filtering and ventilation.

> But the general term, as a verb, is "Lüften" or specifically "Stoßlüften" for the shorter form that is often mandatory for apartments with modern insulation but lacking a proper vent system to prevent mold.

Exactly that.

To add, problems with mold are often due to insufficient insulation in some patches of the wall (like near windows), combined with humid air and insufficient ventilation. A properly insulated house should not form mold. But it is necessary to get humidity out, that's correct.

Not exactly. What you heat is the inside of your rooms, and a significant part of that heat can be felt as infrared radiation. When you ventilate in a quick and intensive manner, you exchange the air, which becomes cold for a few minutes but you do not cool down the room - because that takes longer. And the cold air has very little mass, so it is easy to re-heat again, and will be warmed by the walls etc.

I did that in the last weeks. I live in Germany and we have a flat that is not very modern but has reasonable insulation. What I learned that under these conditions, with two people in a 30 square meters room, CO2 rises so quickly that one has to do intermittent, full ventilation (about 3 to 5 minutes, in Germany it's called "Stosslüften") for about every hour, to keep CO2 levels below 1500 ppm. During the night in a smaller room, one can get easily levels of 3000 ppm. That's not dangerous, but it is not recommended for places where people have to work in a concentrated manner, like offices, or schools, for example. The recommended limit by the federal office for environment is 1000 ppm.

And that build-up of the stuff is a big difference to where we were living before (Edinburgh) where that kind of ventilation was basically unnecessary because no window closed that hermetical (well we lived in one of those wonderful 140 year-old houses in New Town).

In the end, with good insulation, it becomes increasingly important to have some active ventilation - it is also more economical, because it saves on heating. And that is in fact becoming more widespread with new family houses.

I am still using Debian. Debian 10 "Buster" to be precise. But I think I will upgrade, it will be uneventful and everything I use will work as before.

BTW it is a nice combo with the Guix package manager ontop when one needs recent libraries and stuff for development. Saves a ton of time.