End. in peace
Niklaus Wirth has died
261–270 of 412 posts
Re: Niklaus Wirth has died
#262Earlier quoted context omitted.
who are today's new great minimalists?
I use Suckless's terminal, st. It's great. To install it, I compile it from source. It takes a couple seconds. Take a look at their work.
do you think writing st is an achievement that merits a turing award
because i've also written a terminal emulator, and it compiles from source in 0.98 seconds https://gitlab.com/kragen/bubbleos/blob/master/yeso/admu-she... screenshot of running vi in it at https://gitlab.com/kragen/bubbleos/blob/master/yeso/admu_she...
(steps to reproduce: install dependencies; make; rm admu-shell admu-shell-fb admu-shell-wercam admu admu.o admu-shell.o admu_tv_typewriter.o; time make -j. it only takes 0.37 seconds if you only make -j admu-shell and don't build the other executables. measured on debian 12.1 on a ryzen 5 3500u)
i wrote pretty much all of it on october 12 and 13 of 02018 so forgive me if i don't think that writing a terminal emulator without scrollback is an achievement comparable to pascal and oberon etc.
not even if it were as great as st (and actually admu sucks more than st, but it can still run vi and screen)
Re: Niklaus Wirth has died
#263Earlier quoted context omitted.
Hmm, but what if the compiler doesn't use the optimized constructs, e.g. floating point optimizations targeting numerical algorithms?
Life was different in the '80s. Oberon targeted the NS32000, which didn't have a floating point unit. Let alone most the other modern niceties that could lead to a large difference between CPU features used by the compiler itself, and CPU features used by other programs written using the compiler. That said, even if the exact heuristic Wirth used is no longer tenable, there's still a lot of wisdom in the pragmatic wa…
Speaking of that, if you were ever curious how computers do floating point math, I think the first Oberon book explains it in a couple of pages. It’s very succinct and, for me, one of the clearest explanations I’ve found.
Re: Niklaus Wirth has died
#264Earlier quoted context omitted.
(To set the tone clearly - this seems like an area where you know a _lot_ more than me, so any questions or "challenges" below should be considered as "I am probably misunderstanding this thing - if you have the time and inclination, I'd really appreciate an explanation of what I'm missing" rather than "you are wrong and I am right") I don't know if you're intentionally using "colour" to reference https://journal.stu…
> I ask because I've found `async/await` to just be an irritating overhead Then what you want are coroutines[1], which are strictly more flexible than async/await. Languages like Lua and Squirrel have coroutines. I and plenty of other people thing it's tragic that Python and Javascripts added async/await instead, but I assume the reason wasn't to make them easier to reason about, but rather to make them easier to imp…
Bliss 36 and siblings had native coroutines.
We used coroutines in our interrupt rich environment in our real time medical application way back when. This was all in assembly language and the coroutines vastly reduced our multithreading errors to effectively zero. This is one place where C , claimed to be close to the machine falls down.
Re: Niklaus Wirth has died
#265Earlier quoted context omitted.
And these fancy new names aren't there just for hiding the event loop? :)
Sort of and sort of not. The key thing about 2023-era asynchronous versus 1995-era cooperative multitasking is code readability and conciseness. Under the hood, I'm expressing the same thing, but Windows 3.1 code was not fun to write. Python / JavaScript, once you wrap your head around it, is. The new semantics are very readable, and rapidly improving too. The old ones were impossible to make readable. You could argu…
Coroutines are better than both. Particularly in reasoning about code.
Re: Niklaus Wirth has died
#266begin this is terrible news; is there a better source than twitter (edit: https://lists.inf.ethz.ch/pipermail/oberon/2024/016856.html thanks to johndoe0815); wirth was the greatest remaining apostle of simplicity, correctness, and software built for humans to understand; now only hoare and moore remain, and moore seems to have given the reins at greenarrays to a younger generation; young people may not be aware of th…
> wirth was the greatest remaining apostle of simplicity, correctness, and software built for humans to understand
Absolutely!
And equally important was his ability to convey/teach CS precisely, concisely and directly in his books/papers. None of them have any fluff nor unnecessary obfuscation in them. These are the models to follow and the ideals to aspire to.
As an example see his book Systematic Programming: An Introduction.
Re: Niklaus Wirth has died
#267Re: Niklaus Wirth has died
#268Pascal pointer notation was so logical. Dereferencing a pointer was just a caret to the right of the variable.
A double pointer was just two carets. And so on.
There was a struct symmetry about the whole thing. C broke that, especially with strict pointers.
Re: Niklaus Wirth has died
#269Earlier quoted context omitted.
> I ask because I've found `async/await` to just be an irritating overhead Then what you want are coroutines[1], which are strictly more flexible than async/await. Languages like Lua and Squirrel have coroutines. I and plenty of other people thing it's tragic that Python and Javascripts added async/await instead, but I assume the reason wasn't to make them easier to reason about, but rather to make them easier to imp…
Bliss 36 and siblings had native coroutines. We used coroutines in our interrupt rich environment in our real time medical application way back when. This was all in assembly language and the coroutines vastly reduced our multithreading errors to effectively zero. This is one place where C , claimed to be close to the machine falls down.
interesting, i didn't even realize bliss for the pdp-10 was called bliss-36
how did coroutines reduce your multithreading errors
Re: Niklaus Wirth has died
#270Earlier quoted context omitted.
Modula2 was available and got used on Amiga. Silly teenager me found such high level languages "cheating" at the time.
Lords of the Rising Sun was written in Modula2 on the Amiga https://www.google.com/search?q=lords+of+the+rising+sun My understanding (please correct me) is that Turbo Pascal on PC was actually Modula2 ?
The recent discussion here about Turbo Pascal commenters said it was written in assembly. Seems to be supported by https://en.wikipedia.org/wiki/Turbo_Pascal