When teaching computer architecture, why are universities using obscure CPUs? | Hacker News Reader

When teaching computer architecture, why are universities using obscure CPUs?

academia.stackexchange.com

102 pointsredbell115 comments

Many universities use LEGv8 to teach computer architectures, which is a more didactic version of the ARMv8 ISA.

LEGv8 was developed as part of the semi-standard textbook in Computer architectures which is the David Patterson's one.

The problem of course is that this ISA is completely fictional and code written for it cannot be ran anywhere.

Fortunately ARM themselves have developed and made available a web-based simulator of the LEGv8 ISA.

Unfortunately the project is basically abandoned, has critical bugs that impede even the simplest of operations and nobody knows how to develop on it.

That is why for my bachelor's thesis I managed to get it up and running again and added the necessary functionalities to make it the first simulator to run every instruction of the LEGv8 ISA [0].

I am trying to get it merged with the official one so that students and teachers can easily find it and finally use it in their courses, so if any of you uses that textbook in your teaching or you can pull a few internal strings at ARM maybe this could interest you.

[0] https://github.com/simdeistud/LEGv8-Simulator

I do find this exciting about RISC-V is that we might have something that is both simple and teachable, and with enough extensions usable. I first learned to program on an obscure Pascal-derivative language, but now you can start with Python, Java, or even C which are both teachable and usable. So it'd be nice if we could teach architecture with something that served as on ramp to marketable skills.

IIRC, I learned computer architecture with a mythical 13 instruction set ISA. The class started with the basics of using flip flops to build registers and memory, program counters, etc. We had to demonstrate the state of every register at a given line in assembly. We had to write our own assembly. Then we learned C and how to translate it into assembly. The dots were connected from logic gates to to a high level stack based programming language.

I got a lot of mileage out of that class. The knowledge easily translates to other ISAs I’ve encountered in my career.

That was basically what we did at my school. I have fond memories of writing an assembler in Perl to do the machine code assignment so I wouldn't have to calculate the jumps by hand

https://www.arl.wustl.edu/~jon.turner/cse/260/lec/washu2-1.p...

Universities aren’t corporate training grounds.

The job here is to teach you the concepts involved in CPU architecture and using the most general purpose architectures possible that have been developed over millions of person hours to cover every task possible would be a very inefficient way to do this.

> Universities aren’t corporate training grounds.

So the ridiculous fees that correlate to average wages of the profession you graduate into is just a weird coincidence?

Rent seeking causes that correlation (so there is actually a causal relationship): Some professions require certain university degrees. They pay high wages. Universities found out they can extract a rent on future earnings of potential entrants. So you could actually argue that by requiring the degree the firms not only create the rent extraction, but also de facto agree on the curriculum.

So universities (in some quite common scenarios) ARE corporate training grounds?

That's pretty universal (worldwide) I guess? White collar corporate staff that is predominantly unversity educated. That still doesn't mean the curriculum is or should be corporation directed or focused. I know little about this, but India and South-Korea come to mind where there might be more direct links. UK as perhaps a counterpoint where you can find corporate role with an Oxbridge arts degree, or France.

There are no fees for University. See how fun it is when you assume how it is in your country is the same in all the other countries in the world?

So there are no universities that do what I’ve mentioned?

See how fun it is when you assume how it is in your country is the same in all the other countries in the world?

So in your country where the government pays the fees (I’m going to assume that is what you mean by “no fees” as I imagine academics are paid in this country), they do so because they care so much about the wellbeing of academia… or do you think the higher income graduates earn plays a role in increased taxation? Or do you live in a country without income tax?

Funny how people want to attack what you say, rather than refute your actual point: Universities (today) are corporate training grounds.

At least for undergraduate studies, most universities have the same tuition regardless of major (outside of lab fees for courses which need lab materials). The tuition of a particular university is more related to its prestige level than the particular majors its students choose.

I see, and its prestige comes from what? Its contribution to academia? Or its contribution to industry?

Is there a prestigious university that corporates do not value degrees from highly?

Harvard has a relatively lower ranked CS program

And is prestigious for its business school… it’s basically the prototypical corporate training ground

Sounds like you want a trade school.

Imagine teaching a legal class a fictional legal system. Philosophically there's likely great value but I doubt people wanting to practice law would favour courses with that as a focus.

I agree that University courses shouldn't purely be vocational training; there's value to personal growth and pure academia that doesn't have a 1-1 overlap with the corporate world.

That said I certainly appreciate that my time at University has been largely applicable at work. Doing both where possible is likely a valuable goal.

Many law courses spend time on Roman law, and on archaic English law.

Roman law and old English law were actually used in real legal systems, and they are studied because they are the basis for the legal system we use today

I disagree with your second statement. I think they're studied because they are simple working legal systems which are easier to reason about than modern ones.

Arguably these legal systems are the conceptual basis for our modern law system because they are used pedagogically in this way.

In the US (and other countries) Roman and English Law are the "common law" and or "natural rights" that are referred to but generally not stipulated.

"New" governments had a habit of writing up founding documents that focus on the "new stuff" and waving in "all the old stuff" that doesn' conflict with the "new stuff" via a few throwaway phrasings.

As an aside, a class about fictional legal systems sounds quite fun. Then again, I like conlangs too

In school I learned about MIPS architecture, which is fairly straightforward although not in use as much as the more complex x86-64 architecture.

I have worked as a programmer for years and at work have had absolutely zero times I have needed to know x86-64 commands like ADD, JMP, MOV etc.

Actually it is good I learned about other processors since once on a personal project, I compiled C code but it ran different on little endian and big endian chips. If I hadn't learned about other architectures I would have been more perplexed.

As someone else said, law schools teach about Roman law and other forms of law not immediately vocationally valuable. Also - I learned something about non-standard computer architecture as an undergrad, and many people go on to become programmers with a BSCS, lawyers typically go on to get a JD after doing undergrad.

> legal class

I'm sorry, I thought we were talking about computer architecture?

I went to law school. One of the mandatory courses was on roman law. Another was on philosophy of law. Both had zero practical direct value for a working lawyer.

This describes every American law school of which I am aware, where students learn a generalized version of the law through Restatements and study of salient appeals courts decisions, both state and federal.

Barring concerted effort, a U.S. law student will not leave school with detailed knowledge of any particular jurisdiction.

Then graduates take the bar, where they are more or less quizzed on 18th century English common law, because most states use a bar exam that is not specific to each state’s law.

"Universities aren’t corporate training grounds."

Oh c'mon. By the reverse stupid logic corporations aren't educational centers to train newbies on x86 either.

General/abstract is fine and one day one time some how some way make contact with practical too.

Avoiding dumb extremes might be why MIT has a good reputation in stem. It's practical built on solid (often abstract) fundamentals

Because you've only got like 12 weeks and the students are 19. Gotta choose wisely

Modern CPUs are too complicated to teach in a semester. Plus, the course is meant to teach how a CPU works at a conceptual level, not train students for x86 assembly programming.

I had an "Assembly" course in my undergrad that taught x86, we managed in in semester. But it was a separate class from Architecture (and had Architecture I as a pre-requisite). Granted it didn't get into the hyper-optimized / specialized instructions.

IP issues. As I understand it, Harris and Harris changed their textbook from ARM to RISC-V because of IP issues and ARM's lawyers.

The MIPS architecture was also sabotaged by IP issues.

As a result, architecture students are learning how to use and implement RISC-V. Thanks ARM.

Really?! You'd think ARM would do backflips to get the curriculum to include their architecture.

They seem to be improving and do have an "ARM Education Core", but RISC-V has academic momentum at this point.

It's amazing how a lot of companies just forget how they got so big. If people can learn for cheap or at least very cheaply with your stuff, then they are going to use it when making money.

Restricting teaching with it or charging students the high corporate fees are just going to backfire in the long run. People will learn with whatever is cheap or free .

Davinci Resolve is getting more popular, because it's "free" and Adobe is a buggy piece of shit. Blender got popular, because learning at home, with any other software was way too expensive.

Developers developers developers developers

This is also how Linux became the server OS of choice for most companies, while Windows NT remained a niche product only found at a certain kind of company. And before that, easy availability of UNIX to students made it the default OS of any high-end computer throughout the 1980s and well into the 1990s.

One of the reasons why they used Scheme for MIT's 6.001 is because it was an obscure programming language. At the time, some incoming MIT freshmen were likely to have faffed about with computers in high school or before, learning languages such as BASIC or Pascal. Others would have had little to no computer exposure before entering university. Scheme, being a Lisp and having semantics that were quite different from BASIC, Pascal, or any other language such students were likely to encounter, allowed all students to begin on a more or less equal footing because the programming language used for pedagogy would have been equally unfamiliar to all of them.

Obscure CPUs have the same advantage. Plus with careful choice of architecture, or simply inventing your own, you make pedagogy much simpler because the architecture doesn't have all the complicated bits like branch predictors, register windows, speculative execution, etc. that modern CPUs have and you can focus on the basic, "must-have" components.

Less optimizations, simpler instruction sets, easier to implement.

Going from transistors to C is like petrol to driving.

Do you want to learn how a car works by building some 2024 safety and tech enabled car?

Or would you rather start with something that resembles a 60s Beetle but with even less bells and whistles?

But aren't there real architectures that are simple enough? Z80, MOS 6502, Pic, AVR?

Real hardware handles real trade-offs. For example, there are hundreds of instructions in Z80 to support various quirks of the implementation (like the duplicate register file).

Sometimes less is more, and it can be freeing to know that your code compiles to a CPU with just a dozen or so instructions.

It’s the same reason most universities don’t teach git, UNIX, and other industry tools. Sometimes computer science is best seen in its purest form. Same with computer engineering.

And at the end of the day, students should be trained to teach themselves (including things like Git, and Unix).

I'm curious if GP (or anyone else) has been in the position of hiring entry level and finding someone who they felt didn't work out because the new hire was incapable of learning tools. Or the new hire eventually taught themselves?

The culmination of my commmunity college's CS103 class was learning the ins and outs of an ISA called MARIE. only 8 instructions & an editor+simulator written as a java app.

I had a lot of fun spending most of my time in that class writing an entire development stack for that architecture: assembler, simulator, debugger, and eventually a very barebones forth!

Reminds me of the COMP-X machine and CAP-X assembly language that was invented for Japanese IT exams.

It was invented so that nobody taking the test would be at an advantage or disadvantage depending on platforms they had experience with, so the exams could just test pure understanding of the concepts.

But standardized exams being what they are, so many people started studied this specific ISA that eventually it made its way all the way to the US in the form of a few Tandy pocket computers sold at Radio Shack.

Exhaustive article about the history and the ISA here: http://oldvcr.blogspot.com/2024/02/cap-x-and-comp-x-how-tand...

Because my professor hated the x86 architecture. At least I appreciated the honesty.

We looked at some popular RISC and CISC architectures, even looked at Itanium [1] as it was the hot new thing at the time. The professor didn't necessarily hate Intel, just the x86 architecture.

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

x86 should be taught as a follow-up course in the following semester as an example of how not to design a CPU architecture, specifically from the long term evolution perspective.

It would have been fine if x86 ceased to exist after 80486 or 80586, yet it has persevered and has continued to cause trouble with an incessant stream of extensions supplanting the previous generations, or expanding or «enhancing» them: MMX, then SSE (plus a further extension to the extension courtesy of amd64), SSE2, SSE3, SSSE3, then AVX, AVX2 and AVX512, and now AVX10 that is an overhaul of all previous extensions.

With a little bit of the design thinking and future proofing in mind, that hairy abominable mess could have been replaced with a single, scalable vector extension that would have not required a complete code rewrite over the next 30 years. Yet, MBA's over at Intel continued to milk the already ailing cow.

SVE didn't standardize a shuffle usable for processing strings without specializing your code to a specific vector width until October 2022, so it seems a bit unreasonable to expect Intel to have had it in 1997.

Shuffle is different, it is not a foundational SIMD instruction, it is actually a good example of an extension that can be added later as an add-on that does not require a complete code rewrite.

Whereas each of the MMX, SSE and AVX extensions was effectively a new instruction set, AND each had its own register set – 64, 128, 256 and 512 bit registers. Later generations (i.e. AVX2 and AVX-512) are better thought out, but, e.g. MMX – I do not think anyone uses it today, yet it is present in the silicon as the dead space.

Prior art existed long before – Cray had vector instructions first, so it is not like Intel had to invent them from scratch.

Is MMX even still present in silicon, or just shunted away to some microcode?

To my understanding Intel tried to move from x86 with Itanium. That's the consumers who wanted it to linger around.

For some obscure reason, consumers preferred working compilers and higher performance hardware.

I could not use the Itanium server we had at work as it was reserved for the elite. I can say that my 32 bits single core P4 computer was not faster at number crunching.

As someone who was working on Itanium systems at the time, I can confidently say that "consumers" never had a chance to choose Itanium. It was only available on server hardware and Windows ... will there as a version for it but it was slow ... all the compatibility and performance downsides of M1 Macs, and more power hungry too... practically no upside.

It is still a common belief Intel created the Itanium to fool the proprietary unix vendors into thinking they can stop developing their own RISC CPU, but as soon as it happened, Intel gave up on Itanium as well. Solaris lasted a little bit longer only because Sun gave up early on Itanium.

I won't make the argument against variable-length vectors here, but I will note that, although some of the extensions you mention do change the vector length, for none of them is the vector length change the most interesting aspect; you could keep the vector length fixed, and they would all still be interesting. (The exception is avx10, but that is basically forwards-compatible and barely an 'extension', so.)

Contrariwise, although I think some of amd's choices in the initial design of amd64 have hurt its longevity—they could have made more breaks from 32-bit x86, although it is understandable why they didn't at the time—intel has been very careful and has done an extremely good job of playing the hand it's been dealt.

My local university used to teach MIPS, and as of some years ago they’ve switched to RISC-V.

The final assignment at the time I took it was to write a program which compiles a subset of ARM machine code into RISC-V machine code, which was a challenging but so rewarding thing for a younger me to cut my teeth on.

It was a surprisingly modern class too. The in-class material was learning about pipelining, instruction/memory latency, and general CPU concepts, while the assignment and lab material was focused on writing RISC-V assembly and implementing more and more complex programs.

In my best dad voice... Son Im going to need to check your home work.

This sounds like fun little project to learn risk v with. It's on my to do list with a million other things.

MIPS is great. You can learn it in great depth and fully understand the whole microprocessor while compacting it into a single class. You can make your own adder and multiplier with logic gates. It’s a scope that you can actually master

I agree. It's a shame that MIPS is mostly dead at this point.

(And a moment of silence for SPARC and OpenSPARC T1/T2 in particular - full 64-bit CPUs that were used in production.)

However, RISC-V shares most of the implementation benefits of MIPS, is unencumbered by IP issues, and seems to be steadily improving in terms of software and hardware support.

RISC-V has slightly more complicated instruction formats, but is otherwise feels a lot like a cleaned up and simplified MIPS.

The fact that you can easily see MIPS's 16 bit and (most of) 26 bit immediates in a hex editor is one low-key advantage (for teaching) that MIPS has over RISC-V.

But overall RISC-V is a much better teaching ISA. One great thing about is that there is a core version of the RISC-V spec that only has 47 instructions and essentially nothing else. There is no Memory Paging or Privileged Supervisor mode, and you can skip implementing proper exceptions to make the design even simpler.

We learned MIPS assembly as a small part of the computer architecture class at my university, in the first half of the 90s. It makes sense that RISC-V is the modern choice.

The answers don't really go into what I think is the main issue:

An introductory computer architecture course is generally starting from "here is what a transistor is" and hoping to end with "here is how basic computer games work" (e.g., nand2tetris). And has about 40 hours of instruction to do it.

Assembly is but a small part of the course. The ideal assembly language for such a course is one that is simple, something that you can let the interested student figure out how to implement it themselves with just a little bit of prompting. And frankly, most assembly languages aren't up to that task, even if you're willing to pretend that most of the ISA doesn't exist. x86 has issues with things like ModR/M or two-address instructions. ARM has things like r15-is-actually-the-program-counter-and-kinda-special. RISC-V coalesces most of the jump instructions into one or two instructions that is going to complete teaching subroutines in assembly (and also eschews condition codes).

At the end of the day, the stuff you're covering in introductory computer architecture is very far in almost every detail from how modern computers work, and it will take several courses on top of it to actually reach those details. The most important goal of such a course isn't to teach you how they work, it's to give you the information you need to understand the explanations of how they actually work.

Not all of them do --- MIPS was very common once (now probably being replaced by RISC-V), and I've come across recent (<5 years old) lecture slides from Indian universities where they still use the 8086/88, 8051, 8080/8085/Z80, etc.

My university did that switch over in '18. The course originally taught MIPS but shifted to RISC-V, partially though because the book that they taught from was updated from MIPS to RISC-V. I really appreciated the switch, especially as RISC-V becomes more and more relevant.

We use ARM. Because then we can lean on some things (e.g. the ARMlite simulator) UK schools built for A-levels.

You can teach 8086 assembly which is still compatible with modern x86 and it only has like 20 instructions. It's lots of fun I made a whole bootable text editor an assembler and an almost finished lisp interpreter too.

Yeah we learned x86 assembly at my school too. We had to make a “database” (basically a flat file), complete with a text-based ui.

Yeah, though the concept of segmented memory access can be confusing and so far hasn't been very useful this century. :-)

64kb is a lot when you’re hand coding assembly. You just assemble to a .com file and pretend segments don’t exist.

Sure, but one of the fun things you'll want to do from assembler is put pixels or characters on the screen. They're memory mapped outside of segment 0, so you'll need to work with segments to do that.

I think Linux uses it to implement thread-local storage.

No, not really. A couple of features of the architecture and instruction encoding which were historically used for segmentation remain on amd64, and these features are used to implement thread-local storage on every mainstream os targeting the arch, but amd64 is not a segmented architecture in any meaningful sense.

I think the 8086 has 117 instructions. It is a good example of a CISC, after all, with instructions like the one capable of copying a C string: REPNZ MOVSB.

While I have seen many claims that the 8086 has more than 20 thousand instructions that is very silly. By the same criteria any RISC with fixed 32 bit instructions would have 4 billion of them.

Much as I also have never understood universities teaching to "teaching" architectures (DLX), or "teaching" languages (Eiffel - luckily removed from our curriculum before I started), at the same time I did not land a job based on having learned "practical" architectures 68k or MIPS either.

Hey I learned Eiffel. It's a nice language. I wish we had pre-conditions and post-conditions in modern procedural language.

We do - Ada!

I should definitely look more into Ada.

Assertions in e.g. python? Missing the 'contract view', but you could generate docs that pull in any assertions on input args or return value to do something like that.

A lot of my compsci education was in Pascal, which was not exactly a real-world language (though I guess Delphi had a dedicated niche for many years)

I actually think this was probably better than learning with real-world languages?

I believe it taught me to be a computer programmer. Not a Java guy or a C guy or a whatever guy. I think that was super valuable.

For assembly language we learned VAX assembly, which was already hilariously outdated, but again very valuable. It had a very beginner friendly instruction set, much more friendly than x86 which would have been the other realistic choice at the time.

In the 1970's and '80's, Pascal actually was commonly used for real work.

We started out with the Motorola HC11, I'm guessing because someone used it a lot on the past and no one wants to redo all the course material. We used a simulator called "Wookie".

Despite being somewhat obscure, it has the advantage that it is easy to understand while also being real. We had a board where you could hook into the address and data busses, since the memory and busses were external. Also, it has a simple bus, as opposed to an ARM chip with AHB, APB, etc, and no pipelining.

I learned with the 68000 which not only was still a bit relevant and an "industry" chip, it was also simple enough to understand in a few hours assembly courses.

The CPU arch course was with a different teacher and on a made up CPU though. It wasn't even a full CPU we were just learning modules and what they do. Kind of a more advanced (and less palatable) version of the book "but how do it know" (which btw is a great read for the neophyte like me).

When you first learn to fly to be a commercial pilot, why do you start flying silly single-engine cessnas or whatever, wny not hop straight into a 747 cockpit?

You haven't lived until you've done the Tomasulo algorithm on paper for a quiz.

I had undergraduate and graduate courses that studied x86 at 2 different universities.

I think in my days one part of course was some imaginary set and one actual course was MIPS.

Still, picking something simple makes lot of sense as pedagogical tool. x86 is outright mess and ARM is probably going to that direction on long term as well. So something more locked down and fully explainable is the better choice. If students want to do assembly they then can pick what they need.

If my college degree was focused only on technologies that were popular at the time, it would be worth significantly less today. Instead it focused on the concepts and theory that are timeless. When picking an architecture to teach on the goal is to get the best one to give the quickest and firmest understanding of these concepts. With that the right answer is more likely to be something obscure, outdated or even fictional.

The times I've had to write assembly in industry, it has only once been on a mainstream, modern ISA. More often than it is on something that would have never been taught in university (MSP430, PIC18 or other microcontrollers). The theory and concepts I learned in college made those easier to pick up.

Hmm at Berkeley 10-14 years ago during undergrad we used MIPS in both our computer architecture class and compilers class and I wouldn’t call it obscure. Uncommon yes but not obscure.

It had a RISC (Reduced Instruction Set Computer) ISA (Instruction Set Architecture) which at the time was considered academic but not popular in real world computers since CISC (Complex Instruction Set Computer) ISA like amd64 was all the rage but since Apple Silicon and its RISC-based (ARM) architecture that notion has been turned on its head. And the upcoming Qualcomm ARM laptop chip is also following the trend on high performing RISC architecture chips.

The ARM comeback has made RISC popular again for uses beyond mobile phones and academia.

Isn’t the RISC vs CISC distinction a but blurry these days with both ARM and x86 adopting a lot of stuff from the other side?

It's been blurry for over 20 years at this point. ARM has had "cisc-y" complex instructions for almost as long as x86 has been splitting instructions into "risk-y" micro ops.

I think that distinction only makes sense when the hardware executes instructions directly. Like a microcode processor or one that uses jungle logic. But when you decompose optimize and cache the instruction steam on the fly, there is little meaningful difference. Offhand comments from friends more involved in that lead me to think that architecture caught academics flat footed.

CISC/RISC is not a useful distinction and I wouldn't call ARMv8 (at least the 64-bit kind) especially RISC.

Because x86/x64 is horribly CISC. I challenge you to list the instructions a current x64 processor runs in a table. You will get so lost in the extensions it does and does not support that you will give up.

Because Apple's M chips have not been on the market long enough for us to adjust, nor are there cheap versions we can pick up for our hardware labs.

Because phones are not good for teaching computer architecture. We want something with a large screen and keyboard.

If I were teaching computer architecture, I would use an ARM chip in a Raspberry Pi.

> If I were teaching computer architecture, I would use an ARM chip in a Raspberry Pi.

If I were, my students' first CPU would be something like a 6502 -- quite possibly God's perfect CPU architecture. Then move on to something more complicated, RISCy, and 32-bit.

I can not disagree.

Even Knuth uses the MIX assembly language for his hypothetical MIX CPU in The Art of Computer Programming, and those series of books are higher level than Compute Architecture courses.

Those books are also older and have outlasted many CPU architectures.

Because x86-64 is a convoluted mess of optimizations, vestigial instructions and crazy microcode shenanigans that’s evolved the last half century?

Some architectures are better for pedagogy (learning) while still covering the important concepts. RISC-V or MIPS fit this well. RISC-V is also not patent encumbered so anyone can freely use it.

Some platforms are not great pedagogically, but are taught because they are used in industry, like x86.

ARM manages to be ok at both.

I don't see a point in learning with other architectures.

We used Sparc, PowerPC, and 68HC12 (or something in that family). They weren't x86, but they weren't obscure, either. What they all have in common is they instruction sets are small enough to be manageable.

We used 68HC11 for our operating system course and had to write a simple multitasking OS that ran on real hardware. I got to use that OS the next semester to run on a car that needed to follow a track, avoid collisions, and a few other things.

Being a microcontroller you got a bunch of things that today need full development boards right on the chip (ADC, RAM, etc).

Personally I like Niklaus Wirth's minimal RISC-5 (not to be confused with RISC-V). Wirth's systems were simple enough to understand from top to bottom, and RISC-5 was easy to emulate in software or on an FPGA (I also like Wirth's LoLa language.)

https://people.inf.ethz.ch/wirth/ProjectOberon/RISC5.Update....

The point is understanding the concepts and ideas behind different architectures. There is little actual value in understanding the depth of x86 and no introductory course will even try to.

Because universities are pretty conservative institutions which are to a large extent detached from reality, so there's no incentive for them to improve for such issues

I agree that x86 is a terrible choice, but I think there might be middle-ground found in a simplified RISC-V or ARM.

RISC-V is definitely simpler than the MIPS I studied back in university.

At just 40 instructions, it is well-suited for education.

In my day we made (some parts of) a kernel on Motorola 68000-boxes - they were quite main stream at the time.

OT Does anyone know a nice TTL computer with leds to register content that I can buy soldered?

Not what you're looking for I know, but I am reminded of: https://monster6502.com

And: http://visual6502.org/JSSim/index.html

(HN law mandates at least one 6502 post per week. Preferably more.)

And lest we forget (not 6502, not commercial, but some TTL): https://www.homebrewcpuring.org/ringhome.html

Would love a monsterz80.com :-)

We used an on-paper PDP-11 :/

Simplicity. A real CPU is way more complicated than the toy cpus used.

Universities always teach weird stuff. Part of the tradition.

Anecdotally, in my architecture class (granted a decade and a half ago) we had to implement a 4-bit microcontroller from scratch. Using an actual bread board, wires, and primitive chips. We implemented those instructions from scratch given binary input switches and a manual clock. It was a simple instruction set (just ADD, SUB, STORE, RETRIEVE, SHIFT, that sort of thing) but we had to learn everything in depth.

I feel in addition to other valid comments like IP, smaller scope, etc. the simpler instruction set may have something to do with how the newer instruction sets hold your hand a lot. I always thought the point of architecture was to have to learn how things like half-adders, shift registers, and all those work and if the instruction set does it all for you, what's the point?

I do remember in my computer architecture class being a little disappointed we only studied educational ISAs, and ran them through emulation rather than "on the metal". Then in my first engineering job after college, I ended up programming mainly the TSK3000A soft processor, for about a year. Then ARM, some other more weird systems, and finally moved up to module/driver development on the server side. Back on x64, in kernel space no less -- but that was the one instruction set in the whole stack I never had to deal with.

The goal of Uni is to learn the basics and build upon them. Thats why.

mano machine :)

Reply on news.ycombinator.com