There's some bits written in C. Some.

But the system API and the huge majority of, well, everything is hand crafted ARM code.

[1]Start here (main OS startup, after HAL init).

[1] https://gitlab.riscosopen.org/RiscOS/Sources/Kernel/-/blob/master/s/NewReset

The old Apollo workstations & servers during the 1980'2 (before Apollo has absorbed by HP) ran an OS that was written in a a version of Pascal. In incredible system; at one time we ran up a lab of about 20 diskless nodes from a single disked workstation with no appreciable performance headaches.

I started work at TI in 1985 and was absolutely wowed by Aegis running on a few B&W DN320s and colour DN660s. With optical mice on checkered aluminium mouse pads, as I recall. Quite a step up from my BBC model B.

8-inch floppies ftw! ;)

[1]Multics was written in (a version of) [2]PL/I with the added challenge of having to develop the compiler in parallel with the operating system.

IBM has written chunks of its various operating system using [3]PL/S and its successors.

[4]VAXELN , a bit of a curiosity in the Digital Equipment Corporation range of operating systems, was written in Pascal. Chunks of VMS were written in BLISS-32 (though a lot of it was Macro-32).

[1] https://en.wikipedia.org/wiki/Multics

[2] https://multicians.org/pl1.html

[3] https://en.wikipedia.org/wiki/IBM_PL/S

[4] https://en.wikipedia.org/wiki/VAXELN

I actually wrote extensions to VMS in Macro-32 before switching to Bliss-32 after a training course.

This was of course many, many years ago......

Yep. I wrote a new OS Directive in Macro-32 after attending a Kernel & Device driver course. IT would give the user full system privs if you executed a program that called it.

Yes, I know that it was a huge great security hole but I only ever installed it on a machine that was used for testing. I just wanted to prove that it could be done.

When DEC ported VMS from the 32-bit CISC VAX architecture by 64-bit RISC Alpha, they wrote a compiler to translate the MACRO assembly language into native Alpha machine instructions, treating it as a high level language. (Some of it even had block structure, using the powerful macros that the assembler did indeed have.)

Some notable OS's have been written in Assembler but tend to get forgotten.

My personal favourite is RSX-11-M/M-Plus/S

I had great fun modifying the boot code for 11S so that some extra custom features were enabled. Those were the days when IT was fun and there was always something new happening.

Fairly sure MSDOS precedes 8086 C and was written in assembler, as was CP/M...

Yes, MS-DOS was a bought in reverse engineering of CP/M 86, which was assembler. Much of CP/M 86 and CP/M 86 or DOS Apps were auto translated from 8080 code to 8086 by an Intel tool. The 8088 / 8086 was really a superset of 8080, hence the awful 64K segments and no 16 bit flat addressing like all the true 16 bit cpus in early 1980s.

Early C was barely more than a Macro assembler and the most common C bugs where/are

Unexpected expansion of the macros

Array bound violation because no compile or runtime checking. purely null terminations. Both Modula-2 and VB6 had a far better way of doing strings. C++ also had a better way of doing strings from about 1988, but mostly ignored.

Libraries buggy or misunderstood.

No strong typing, issues with parameters, inappropriate casts (Solved and ignored in C++, solved better in Modula-2).

Inappropriate use of pointers (dereferencing pointer to unallocated RAM, arithmetic etc).

Big failing of C++ was AT&T's insistence on backward compatibility. Strustrupp didn't want it and it's been crippling since.

From the article:

This is not intended to be a comprehensive list. There are too many such efforts to count, and that's even with intentionally excluding early OSes that were partly or wholly written in assembly language.

I think they know about them (and so do we now, thank you!), but them there presses were sitting impatient to go.

Wow, some memory from my Amiga years. I'm sure I spotted a modula 2 compiler in my tools library !

What about Prolog ? It was weird and fun, although I don't remember it to be useable outside of solving puzzles ...

An OS written on Prolog would just be, well, "diseased" is the kindest word I can think of!

An OS written on Prolog would just be, well, "diseased" is the kindest word I can think of!

Take a look at the [1]Japanese Fifth Generation project . The idea was that the resulting machines would run Prolog natively.

I was at the conference in Bristol in the early 80s when they did their big presentation over here, and got to talk with the people who'd actually be doing the research(*). I was fairly cynical about the idea so asked them if they thought it would work. Their reply was on the lines of "Who cares? We've got 5 years of big funding and will get another 5 years unless we totally screw up in the first 5. It's a government initiative so will never be deemed a failure."

(*) As opposed to the nominal heads who were basically political academic players and government placemen, and too busy glad-handing their UK and European opposite numbers to speak to low-lifes like me.

[1] https://en.wikipedia.org/wiki/Fifth_Generation_Computer_Systems

It ran Forth Programs on a Z80, but I don't know what its minimalist OS was written in.

I wrote an almost OS in Modula-2 for x86 to run a Game engine. It only used DOS to load and had simple co-operative multitasking using coroutines. I wrote drivers in M2 for keyboard, CGA, Hercules, EGA, VGA, soundblaster PCM & MIDI and audio on PC speaker. It could do MIDI music, sound effects on PC speaker, SB audio, scroll background, move foreground tiles, animate sprites, multi-key input and read HDD all at the same time. Performance as good or better than assembler coded games. Though only using 8086 compilation it needed at least IBM AT compatible hardware rather than XT for various HW timers, DMA etc.

Sadly getting artwork done was too much work.

It ran Forth Programs on a Z80, but I don't know what its minimalist OS was written in.

Forth is a minimal OS in its own right usually. That's how it started out.

I don't know what its minimalist OS was written in.

[1]In Z80 assember , like its Sinclair cousins.

I say cousins because it was designed by Richard Altwasser (hardware) and Steven Vickers (software) after they finished working for Sinclair.

[1] http://www.jupiter-ace.co.uk/romlisting.html

The Dragon32 had a Forth OS IIRC . Small, tight fast and with a complete lack of software.

Not joking, the early versions of PR1MOS, the OS for Prime machines, were written in Fortran 4 (with a few system-ish hacks like a predefined common block that was all of memory, and assignments missing left or right sides to set or get the accumulator). Later versions were in PL/P, a systems programming dialect of PL/I.

My first ever proper job - aged 18 - was on Prime's coding in PL/P. Happy memories.

There's a reference [1]on Wikipedia to an operating system written in COBOL. While I can find other sources for the existence of the product and its focus on running COBOL applications, I'd be interested to see some confirmation of the extent that COBOL featured in the OS, particularly given the variety of peripheral hardware it apparently supported: I don't fancy writing a device driver in COBOL...

[1] https://en.wikipedia.org/wiki/BLIS/COBOL

Well, I don't fancy writing anything in COBOL.

ah ..

SMSG$, which was a wrapper to MSG$

there was also the proto TCP stack (using X25 ?) that daemons used.

One of the many varieties of OS / language from the 60s, 70s, had to win, it just happened it was C and UNIX.

What really cemented it though was the US DoD, in the 1980s, effectively plumping for the UNIX and C with POSIX. That cast an official US governmental seal of approval on C and *nix style operating systems, and that was that. At the time it was rapidly becoming the de facto choice anyway, but after that there was no money to be made in developing something radically new and trying to sell it to what was at the time one of the biggest customers in the market.

Actually USA DoD plumped for ADA in 1980s. C was a decade earlier.

GNU, BSD etc and later Linux born because the developers of UNIX thought AT&T unfairly had copyright. A lot of it wasn't paid for or developed by AT&T.

POSIX is a separate thing from UNIX.

That's just not true.

Unix and C won in the 1980s because (a) they were far superior to the alternatives; (b) vendors could port Unix and C to their hardware far more quickly and cheaply than developing and maintaining their own OS and compilers; (c) the market was moving to desktop workstations and these mostly ran some variant of Unix; (d) customers and developers really liked the concept of open systems (=> no vendor lockin through custom APIs and supposed ease of migration between vendor platforms); (e) Unix IPR was open to any vendor on equal terms because it was owned by AT&T which wasn't allowed to be in the computer business and therefore couldn't use Unix to eliminate competitors.

The DoD did insist on POSIX compliance - sort of. But they didn't enforce this. Not that (lack of) POSIX compliance hindered sales to the DoD from Microsoft, DEC, IBM, DG, HP, Burroughs etc. They still bought shitloads of non-Unix mainframes, PCs and minis from those vendors.

Back in the 80s, it was considered witchcraft that the same source code could compile and run on different hardware and software from the likes of DEC, Sun, HP, IBM and the rest. Today we take that for granted. Unix and C made that possible.

This article is the equivalent of the era of bubonic plague when a guy with a cart went around saying "bring out your dead, bring out your dead".

Heh, I do agree but...

"bring out your dead, bring out your dead"

I can't quite yet. We still need our dead to run the entire industry ;)

Not to mention, dead stuff is always more stable. I.e you wouldn't exactly build a house out of *living* people would you?

This article is the equivalent of the era of bubonic plague(*)

In some cases it's more

Your father's OS. An elegant system for a more … civilised age(**).

Multics, Burroughs' MCP and Genera all had features that today's mainstream OSes lack or do badly.

(*) First known bubonic plague outbreak was ~3000 BCE, it's still around today. Long era.

(**) [1]ObXKCD .

[1] https://xkcd.com/297/

Xerox Parc machines could and did run Smalltalk-80 all the way down to the bare metal.

For a brief moment HP (nearly) had a pure Smalltalk-80 box running on a NatSemi 32032. I had a prototype to play with under NDA and for the time it was a rather fine, if specialist, workstation. However, it developed a hardware fault so they took it back on a Friday and by Monday HP had always been at war with Eastasia had never had a Smalltalk machine and never even considered developing such a thing. If it hadn't been for the h/w fault I might have managed to keep a non-existent HP ST-80 box as a home computer.

MacOS < 7.0 was Pascal. I don't think they ever replaced it all with C before OS X.

The scariest ever and now dead OS from the 80s was the thing that ran on Symbolics Lisp workstations. IIRC it was written in Lisp and let the end user change the CPU microcode (also written in Lisp?) on the fly whenever they felt like it.

I think the core Lisps were generally built around SECD machines which I guess you easily implement in machine code (CAR and CDR were taken from the machine code of the IBM704), Or equally simply create a hardware implementation of it. Symbolic Lisp Machines made machines with that in mind but never quite got round to doing it fully in silicon.

You can create OS and applications in any language really.

But some lack the dirty aspects of memory management (and even lower like CPU protection switching) so they need bits in assembler or something C-like. Equally such low-level code has enormous potential to screw the system.

Horses for courses really, and most decisions come down to what will do this job well enough to get by.

Lawrence Livermore needed an operating system with more features than what was offered by the vendors of supercomputers at the time - classified level support, time-sharing, etc. So they rolled their own. LTSS for the CDC and Cray machines, CTSS for Cray hardware, and later a new version of LTSS - NLTSS for Crays. All of these systems, utilities, support libraries were written in the local dialect of Fortran-77, later Fortran-90.

All of the systems used concepts developed for Multics, but were heavily modified to suit the needs of the laboratory computing community. One notable feature was the mapping of program memory to disk ( aka core dump ) was also used for swapping out when the time slice expired AND was restartable.

Eventually these systems were replaced by Unix derivatives - notably Linux.

I suppose [1]TempleOS belongs in the C-like category. Written in HolyC.

[1] https://en.wikipedia.org/wiki/TempleOS

Yeah, right. My ass.

Here's the thing: people who write C or C++ software don't feel the need to spam the world with announcements, pronouncements and self-promoting spam. They just do shit, quietly. It happens to be shit of consequence.

But, there's a small community of Rust fanbois who are just very loud. And that's because that part of the world where consequential stuff happens doesn't pay much attention to them.

So, Rust wants to stick its tail into the Linux kernel. Wants to hang out with the bro's. Respect Mah Authoritaaaaay!!! [0]

How did that go? Whoops! Thar she blows. Something about operating systems, ABI's and calling conventions.

Rust's reaction? Fuck C!!

And it's not even because Rust has something concrete to offer to the Linux kernel. The prevailing advantage of Rust over C that's being pushed around by fanbois is: it's safer to write in Rust than in C . Translation: Rust makes an inept C pointer boob less of an inept boob. And that's somehow reassuring?

It's just an ego trip. Rust wants to be in the Linux kernel because it thinks the Linux kernel is cool , so that's where Rust wants to hang out. With the cool kids.

Know thy limits, Rust. You're just a pile of marketing talk being pushed by Microsoft and Google, in their quest for the complete monkeyfication of the software engineering profession.

-----

[0]: Cartman. See: South Park

Have a beer sir. Sorry about the icon but it was the nearest I could get to oxidisation.

When I was reading the article I just knew there'd be a 'rust angle' in it somewhere. It wasn't _really_ about C was it.

I think we're going to need another icon before too long, rust gets way too much air time here, it's in danger of becoming the new systemd.

Ouch " C fans tend to regard BCPL as an unimportant transitional step "! BCPL has more expressive flow control than C, it's compiler is designed for easy portability to new architectures, and it's closer to the machine for systems programming. Back in the day I've worked on compiler and run-time library ports across multiple target platforms that allowed a single application code base to work seemlessly across them all. Ah, nostalgia ain't what it used to be...