oso2k

RM machines usually have more Memory Modes with which to access memory. You can do a math op while indirectly accessing a memory address that depends on a calculation of that address and add and offset to it. So that makes programming many things easier. It’s a little more how humans learn and think of math. Think using arrays, lists, vectors, hashes, trees. However, this often generates data dependencies which makes pipelining and ILP require more work to achieve efficiently. It also often makes the code dense.

https://en.m.wikipedia.org/wiki/Register%E2%80%93memory_arch...

LS is generally found in RISC machines and is also generally considered far easier to implement pipelining and ILP. Fewer and often simpler Memory Modes, more obvious or simpler to deduce data dependencies. But it often takes a few more instructions to complete an algorithm or even a simple expression. Less code density.

https://en.m.wikipedia.org/wiki/Load%E2%80%93store_architect...

There’s also stack machines which approximate math well especially if you like RPN/prefix notation. They just tends to make logical constructs like loops look unfamiliar when compared to math or typical/popular programming languages. So it makes programming easy, compiling easy since it’s relatively natural to analyze & compile expressions. Also, instructions can be extremely compact such as single bytes.

https://en.m.wikipedia.org/wiki/Stack_machine

Another slightly related take was VLIW. You take snippets of instructions (Basic Blocks in PL) that are known to fit certain pipelining or data dependencies rules. Theses blocks of code can then be executed concurrently since you have well established criteria. However making compilers able to predict when blocks should execute in the presence of a complex single processor turned out to make writing the compilers very complex.

https://en.m.wikipedia.org/wiki/Very_long_instruction_word

No (potential) customer is required to make any company profitable.

More than 20 years ago, there was another C-like compiler for Flat Real Mode[0] called BFlat[1][2]. I want to say there are other tools called BFlat or some near variant.

[0] https://en.wikipedia.org/wiki/Unreal_mode

[1] http://www.lanet.lv/simtel.net/msdos/misclang-pre.html

[2] http://www.lanet.lv/ftp/simtelnet/msdos/misclang/bflat050.zi...

There's an old an OS-free/BIOS-based implementation of FAT12 called MDCFS.C (Minimal Dos Compatible File System) in Dave Dunfield's EMBEDPC.ZIP (only in the Internet Archive now). You'll also need peek at DK86IO.C from that zip as well as come up with an implementation for those BIOS calls. Dave's been active on vogons lately.

https://web.archive.org/web/20210505023207/http://dunfield.c...

Yeah...it's like Windows version of Jenga. Which piece will make the tower crumble?

Don’t forget the discord either.

There's a bunch of homebrew 8088, V20, and V40 "XT" boards out there now. I bought a few related boards plus a V20 and V40 from (https://www.homebrew8088.com/).

This one is fine. But I had better luck on my booted CAT6A cables with this other design. The longer one is what I used and even then, I had to shave the nose a mm or two.

https://www.thingiverse.com/thing:2009495

One upon a time, Crockford worked on ADSafe for a similar goal.

https://www.crockford.com/adsafe/

FS4 was also part of Windows/DOS Test Suite and archived as such in the MS FTP Site.

ftp://ftp.microsoft.com/Products/Oemtest/v1.1/Winstress/stress/i386/stress/dos/fs4/

It is related because a naïve program will access a device (CPU registers, instruction pipelines, indirect cache access, RAM, disk, optical disk) in a linear fashion. RAM no longer has linear or near linear access. Disk drives of all types dealt with rotation speed, spindle head speed, etc. For a long time, disk specs were recorded in linear/sequential access time, full seek access time, and average random access time until sequential access time became less than 1ms and OSes/disk cache programs made average random access time the only latency worth caring about.

In summary, most storage devices have hierarchical performance and it’s worth caring about how to optimize for that.

In early 2000s we used to send each other messages using Query Strings or X-Headers....

Very cool project. Would love to seem more projects that use PicoW, 02W to bring 20th century HW into the 21st. And I love BIOS font theme!

In CS, that is more generally called scheduling or pipelining. And they’re forms of queuing theory and capacity resource management. For me, multitasking is the introduction of prioritization into the task queue management. In the above post, there’s a Finish-to-Finish prioritization introduced. We want hot burgers and nachos to complete at the same time or nearly the same time. So, yeah, I’d call that multitasking.

One of these days...I'll build a Pi Virtual Floppy

https://www.smbaker.com/raspberry-pi-virtual-floppy-for-isa-...

k8s is really just a lot of Linuxisms put together in semi-novel, intelligent, and pluggable way. That list of features u/orf posted is all possible with plain Linux. You can start really minimal k8s, almost like plain containers on Linux. But going from one machine and one container/workload to literally 100k containers, 100s of machines and workloads working together in secure ways is really difficult without the organization that k8s APIs, interfaces, automations, and concepts impose on Linux.

I've helped an 80% new team survive Black Friday and make $10M revenue in 3 hours in a 6 week engagement. I helped a 100% new team build their first CI/CD system to build/run/test their aircraft embedded system in containers. I’ve helped credit card companies scale dozens of clusters to 150k services under management backed by over 250k containers, per cluster.

And it’s the same code that will run on a 10 year old PC or RPi3B as a single instance. It really is a story about the power of Linux.

And then a controller or operator heals it.

Have you looked at the postings on comp.compilers, lambda-the-ultimate, and other places where PL folks hang out?

Also missing is the misnomer “USB hard drive”.

The oldnet makes serial WiFi bridge adapters. Fake dial into an ISP like an old machine would expect to and now you have WiFi access.

https://www.tindie.com/products/theoldnet/rs232-serial-wifi-...

https://youtu.be/jQD89Gxmuas

https://youtu.be/cj98AnFhVXk

There’s also pimodem http://podsix.org/articles/pimodem/

Interesting. Thank you for the info.

I hear ya. Maybe you could argue that GNU, BSD or a few other groups were using SCCS but that’s relatively very few developers in comparison to the DOS, Windows 3.x, Amiga, BBC, Apple that we’re producing more code at the time. I’ve seen few bits of early NASA/JPL code and it wasn’t in source control, it was on NFS.

I haven't looked into deeply but I've heard stories from others with Ryzen boxes that ECC features of the RAM are turned off with Ryzen CPUs installed. Supposedly you can see this in Linux w/dmidecode or other tools. I'd appreciate good links if anybody has them.

PS: https://www.reddit.com/r/Amd/comments/lh3m42/demystifying_ry...

https://www.reddit.com/r/Amd/comments/ggmyyg/an_overview_of_...

It’s always a question if the source is still around now or on accessible media. Especially if said products were part of one or more acquisitions. Source control usage has only been popular the last 20-25 years. Before Linus wrote git, the Linux kernel was kind of responsible for even making the idea that source control systems should be part of the development process in popular OSS. Zip files, tarballs, directory dumps were popular in the early and mid 90s. Super hard to get sources out if it’s stuck on a special machine that wasn’t network connected, maybe exotic media like WORM drives, kangaroo drives, backpack drives, 5.25” floppies, etc.

I'm hoping Japheth finds some useful info and adds that to JEMM.

https://github.com/Baron-von-Riedesel/Jemm

There's also a few NE2000 ISA clones on github now.

https://github.com/Manawyrm/ISA8019

https://github.com/hkzlab/ISA_8bitNetwork_8019

https://github.com/skiselev/isa8_eth

Thanks a ton Mike! One of these days I want to start working on a djgpp version of the library code. 32-bit clients could be useful for some things.

I’d give Brian Kernighan credit for a lot of the userspace of early UNiX. Besides awk, he wrote and/or contributed to many other tools, wrote lots of documentation, man pages, filmed videos introducing UNIX, played historian and documentarian roles as well. Today, you might call him Technical Marketing Manager or Developer Advocate. He did a lot to make UNIX usable and known to the world outside of AT&T.

The UI is based on a framework that is open source. It’s called PatternFly.

https://www.patternfly.org/v4/demos/dashboard

It's because dynamic recompilation as done in VirtualBox & QEmu is on the order of 10x slower than CPU accelerated/supported virtualization. You don't notice that (as much) with DOS or a simple Windows 9x VM. But you will notice that if you're running busy SQLServer, ISS, .Net, Linux, PostgreSQL, MySQL Servers.