There are 14 competing standards…

I thought this old antirez “mythical 10x programmer” post was pretty good:

http://antirez.com/news/112

I’m old enough to remember when printers DIDN’T break. I’m sure lots of HP Laserjet II’s from the 1990s are still cranking out hundreds of pages per day today. Same thing with Okidata dot matrix printers from the era, for those who still want to use them. It was later when printers became crap.

G Stylus 5G 2023, Android 14, kernel 5.10.198-android12-9-bunch more numbers. Does that help?

Can you verify with wireshark that the traffic is only going through your lan? I’m not hip enough for nginx but I used to have to run apache under gdb all the time to trace random errors from the server. That would be next, if the traffic is really local.

Don’t forget Algol-60. Per Tony Hoare, “Here is a language so far ahead of its time that it was not only an improvement on its predecessors but also on nearly all its successors.”

Back in my day, we only had ones and zeros, and sometimes we ran out of ones!!! (From old song, https://youtu.be/p1fBd7UbQPA?t=60 )

There was a famous incident of a badly designed PD cable frying Benson Leung’s fancy ($2000) Pixel Chromebook or something like that.

Can anyone explain why Wayland exists or who cares about it? X has been around forever, it sucks but it works and everything supports it. Alternatives like NeWS came around that were radically better, but were too soon or relied too much on corporate support, so they faded. The GNU project originally intended to write its own thing, but settled for using X. Now there’s Wayland though, which seems like a slight improvement over X, but mostly kind of a lateral move.

If you’re going to replace X, why not do something a lot better? If not actual NeWS, then something that incorporates some of its ideas. I think Squeak was like that but I don’t know much about it.

Org mode has a time tracking feature, dunno about report generation.

Off the topic of my head, maybe these can get you started:

Hackers, by Stephen Levy

The Hacker Ethic, by Pekka Himanen

True Names, by Vernor Vinge

Free Culture, by Lawrence Lessig

A Fire Upon The Deep (SF novel), by Vernor Vinge

Forth is fun but not really suitable for large, long-lasting projects with huge developer communities. Linux isn’t being bootstrapped, it’s already here and has been around for decades and it’s huge. And, I think bootstrapping-by-poking-around on a new architecture has stopped being important. Today, you have compiler and OS’s targeted to the new architecture under simulation long before there is any hardware, with excellent debugging tools available in the simulator.

I don’t think Ada in the kernel would get any cultural acceptance. Rust has been hard enough. C++ was vehemently rejected decades ago though the reasons made some sense at the time. Adopting C++ today would be pretty crazy. I don’t see much alternative to Rust (or in a different world, Ada) in the monolithic kernel. But Rust seems like it’s still in beta test, and the kernel architecture itself seems like a legacy beast. Do you know of anything else? I can’t take D or Eiffel or anything like that seriously. And part of it is the crappiness of the hardware companies. Maybe it will have to be left to future generations.

I have played with Ada but not done anything “real” with it. I think I’d be ok with using it. It seems better than C in most regards. I haven’t really looked into Rust but from what I can gather, its main innovation is the borrow checker, and Ada might get something like that too (influenced by Rust).

I don’t understand why Linux is so huge and complicaed anyway. At least on servers, most Linux kernels are running under hypervisors that abstract away the hardware. So what else is going on in there? Linux is at least 10x as much code as BSD kernels from back in the day (idk about now). It might be feasible to write a usable Posix kernel as a hypervisor guest in a garbage collected language. But, I haven’t looked into this very much.

Here’s an ok overview of Ada: http://cowlark.com/2014-04-27-ada/index.html

Rat out my friends by telling Google their DOB? Will they also add a field for mothers’ maiden name? No thanks.

OOP was a 1990s thing that is still around but don’t worry about it too much at first.

The classic intro book is Structure and Interpretation of Computer Programs aka SICP. You can find it online with a web search. It will give you a good grounding in fundamentals. Then you can figure out what to pursue next.

C, C-like, or Rust

As always, Ada gets no respect.

I’ll look at the wiki article again but I can pretty much promise that Ada doesn’t have dependent types. They are very much a bleeding edge language feature (Haskell will get them soon, so I will try using them then) and Ada is quite an old fashioned language, derived from Pascal. SPARK is basically an extra-safe subset of Ada with various features disabled, that is also designed to work with some verification tools to prove properties of programs. My understanding is that the proof methods don’t involve dependent types, but maybe in some sense they do.

Dependent types require the type system to literally be Turing-complete, so you can have a type like “prime number” and prove number-theoretic properties of functions that operate on them. Apparently that is unintentionally possible to do with C++ template metaprogramming, so C++ is listed in the article, but actually trying to use C++ that way is totally insane and impractical.

I remember looking at the wiki article on dependent types a few years ago and finding it pretty bad. I’ve been wanting to read “The Little Typer” (thelittletyper.com) which is supposed to be a good intro. I’ve also played with Agda a little bit, but not used it for real.

Look on lineageos.org for their list of supported phones maybe? I thought you wanted to program the camera itself, in which case you might have an easier time with a standalone camera than with a phone camera.

Dependent types only make sense in the context of static typing, i.e. compile time. In a dependently typed language, if you have a term with type {1,2,3,4,5,6,7} and the program typechecks at compile time, you are guaranteed that there is no execution path through which that term takes on a value outside that set. You may need to supply a complicated proof to help the compiler.

In Ada you can define an integer type of range 1…7 and it is no big deal. There is no static guarantee like dependent types would give you. Instead, the runtime throws an exception if an out-of-range number gets sent there. It’s simply a matter of the compiler generating extra code to do these checks.

There is a separate Ada-related tool called SPARK that can let you statically guarantee that the value stays in range. The verification method doesn’t involve dependent types and you’d use the tool somewhat differently, but the end result is similar.