Rochus

Thanks for these interesting insights. It's hard to imagine today how scarce computers actually were at that time. The assembler was for the System/360?

This is a very interesting talk. I'm amazed to hear how good this AI stuff already is (if I take DHH's statements at face value).

Well, since everyone already has the specs, they should release it as a free standard.

"Buy now - 10$"

Cool project. Good idea to use SDL3; it brings along much more than SDL2 where you had to use a lot of other libraries to become platform independent with all features. The disadvantage might be that SDL3 itself (as SLD2) is pretty big. Ada got a bit out of fashion (unfortunately) but it's still an impressive, excellent language. Still an interesting choice. Maybe you can give more information about your choice and plans with the GUI library.

Have a look at boost::movelib::unique_ptr<T> which works well with C++98/03.

I guess people will avoid this country/island alltogether when these such sentences get commonly known. Maybe that was the intention, i.e. to reduce overcrowding due to tourism?

Interesting. Since I have the T480 I have to switch off variable speed when doing benchmarks and switch off all but one core.

Have a look at Qt implicit sharing. There is/was also a Boost library which could do most of it long before c++11.

For all of my projects it is good enough. C++11 onwards has a few advantages, but I don't need them. Moving ownership between containers to avoid allocations was possible with the standard library even before C++11, and Qt offered "implicit sharing" which has a similar effect without syntax changes and incompatibilities. Even with my C++11 projects (e.g. https://github.com/rochus-keller/eigen/) I had to take care still in 2024 which feature not to use on MSVC because it didn't work or behaved differently. I never have any ownership issues and I implement large compiler projects with different AST and IR layers. All my projects still compile with https://github.com/rochus-keller/leanqt/ on all platforms. I would never trade a tiny language advantage with a whole world of dependability issues. One day I will revive and refactor GCC 4.7 to get a cross-platform C++98 with parts of 11 compiler just written in C, then latest all of my software is buildable "from first principles".

PS: it's funny I wrote my comment three days (and not an hour) ago.

Very interesting summary of facts and quotations with conclusions. I would say there are even more camps than the two mentioned. Personally I think C++98 and Qt5 just worked and were good enough for all purposes, and C++ since has become an ever moving target with a lot of incompatibilities between compilers. Chasing for the ever latest version of the language and compilers is very expensive and enervating. I prefer how they solved this e.g. in the Ada community; they take their time for the release a new standard version, and until then, most compiler vendors have already updated their products and there was relevant experience with the new features long before the new standard was passed. In computer science, it seems to be a law of nature to keep "improving" good things until they become unusable and people walk away. In C++ I did so; I have a few C++11 code bases (some back ported from newer versions), but most are C++98/03; I even made a fork of Qt5 (LeanQt) with my own build system (BUSY) which is less work to maintain than continuously chasing new compiler/tool incompatibilities among platforms.

Welcome to the "CARA club" (http://www.cara.nmr.ch/doku.php/Home). Obviously a good acronym ;-)

Is this an AI generated response? It has nothing to do with what I wrote, what I demonstrated or my actual experience as a trained musician. Your text sounds very generic, obviously without checking my sources. Nobody requires you to have interest in things you don't like, and you are free to prefer the slop you are served by the "big four" of the music industry. Btw. Zappa would have liked today's possibilities (just have a look at Francesco Zappa or Jazz from Hell, and his justification “if they can’t play it, then why should I be denied the privilege of hearing what I imagine and what I write").

Wow. Must feel like a completely different world compared to today. May I ask what your work was?

Great story, thanks. I wasn't aware that the Critical Path Method originated from DuPont and Remington Rand. Almost lost art today. When I proposed it in a government project twenty years ago here in Switzerland nobody seemed to have ever heard of it.

> is anybody using this slop for entertainment?

Yes, from time to time I buy a subscription and upload my songs to see what comes out. Very entertaining. If you know how to handle it, the output is far from slop; see e.g. https://rochus-keller.ch/?p=1428. The whole point is, that this is just another "instrument" (i.e. a means to make music, as was the drum machine in the eighties, or the Fairlight for those who could afford, or all its much cheaper alternatives in the nineties to this day). The "instrument" doesn't replace musicality and abilities, but it enables people who have those to make (good) music.

I have mostly experience with the smaller (older) boards of OrangePi, and I think they have great boards, some even with a long availability.

People unaware of Project Oberon should rather have a look at https://projectoberon.net/ where they can find the free book and additional material by Prof. Wirth.

Thanks. Though I migrated the code from Oberon-07 to Oberon 90 (so I could compile it with my OP2 version) and currently I even migrate it to my forthcoming Micron language. The Project Oberon System is very well suited for these kinds of experiments.

Thanks. I rather do it as a "proof of concept" to demonstrate that the Oberon System is a (hopefully) great fit with today's microcontroller boards, particularly the Olimex ESP32-P4-PC, which even has a HDMI connector. I already migrated the system to the Raspi Zero 2 which is yet another lean target, but actually oversized for the Oberon System, which doesn't even require an MMU (not to mention multiple cores). The networking support code is currently not used, because it would require yet another (pretty complex) driver. But it might be feasible (with a lot of patience) to implement it directly on the board as soon as the system and compiler run stable on it.

And shortly after Wirth launched his RISC-5 system, the original FPGA board went out of production.

The ESP32-P4 is actually my target platform. I have a cross-compiler toolchain based on my own OP2 compiler version (see https://github.com/rochus-keller/op2/) which makes it easier to migrate. The Project Oberon System is an "intermezzo" for my actual goal, the Oberon System 3; the latter can also run my OP2 version and would thus be able to self-host. I didn't try yet to run OP2 under the Project Oberon System, but with some patience I assume it is feasible.

The availability of the board to run Wirt's system was an issue pretty soon. There were even people who offered their own boards to fill the gap (e.g. https://web.archive.org/web/20160831063355/http://oberonstat...).

My system version instead runs on RISC-V, so no custom FPGA implementation, currently on an emulator, but eventually on the ESP32 (which has a much better availability).

One could obtain and run an old (Open) Genera image with a VLM port from archives or community distributions. What is announced here is that "Symbolics Technologies" is now formally offering Genera and the VLM under a free-for-non-commercial-use licence. But it's not open source as it seems.

I get a 504 Gateway Timeout. Here is a working copy: https://web.archive.org/web/20260410221550/https://brightmar...

> Simula 1 and Simula 67 [..] are recognized as the first object-oriented programming languages

This only applies to Simula 67. Simula I was a discrete-event simulation language. It didn't have the features which we today associate with "object-oriented".

> Alan Kay [..] introduced the term “object-oriented”

Did he? See https://news.ycombinator.com/item?id=36879311.

Just a regional court anyway, barely worth the news.

Wow, this is incredible. What are you doing with it? Looks like a year of work.

Ok, I see. The S3’s "MMU" is just an external-memory mapper, not a virtual-memory MMU. The S31 apparently has both, that mapper plus an architectural CPU-side Sv32 MMU; that offers indeed a lot of interesting possibilities. Even sel4 would run on this machine as it seems. The ARM world has no microcontroller with a true MMU as far as I know. Risc-V now has at least two (here is the other one: https://www.bunniestudios.com/blog/2026/baochip-1x-a-mostly-...).

Sure, but what the S31 calls "MMU" is not an Sv32 MMU; therefore my comment.

Thanks for the links. This doesn't seem to be a true RISC-V MMU (according to the Sv32 specification) integrated into the CPU core itself, but just a peripheral designed for memory mapped SPI flash and PSRAM. So as far as I understand there is no true process isolation with page faults and dynamic paging.