https://www.amazon.com/Code-Language-Computer-Hardware-Softw...
The beginning chapters that work through relays and logic gates make this leap to how we create memory and do logic that made me realize we are, quite literally, harnessing electricity (think: mana) to etch arcane runes (circuitry) that perform feats that are effectively magic.
This must be why I like reading books that have software developers as magicians (see: Off to be the Wizard).
I struggled with the chapter on combinatorics but the book is amazing and I love the illustrations.
You may as well learn C and the guts of microprocessors if you're really concerned about how a computer actually operates.
Web development really just treats the whole of the internet as one big computer, and the dev formats interesting content nicely for the screen of the user, which is ultimately about presenting useful data. There's probably little incentive to take a "year off" to try and understand the whole thing from the physics to the electronics to the logic to the anthopology and philosophy of computation - it's too big a field and something you'll be spending the rest of your life doing. Plus even in a year, starting from scratch, even with 8-bit kits or transistors, any computer you make when compared to modern machines won't really even do anything. Imo you'd be better off getting a ZX Spectrum, a cassette drive, a copy of Manic Miner, and enjoying watching the 48kb of it load into the machine, then pouring over the code. Or even Elite on the BBC Microcomputer. Understanding these few thousand kilobytes of machine code and how they interact with the machines is easily food for thought for a year. Then just multiply that by a few thousand in terms of resolution, bandwidth, speed, and you'll understand modern computation better.
Or just go travelling for a year and don't think about computers...
The RC2014 is a good cheap beginners' kit, I hear.
1. Start with a ROM BASIC.
2. Upgrade it to run CP/M and learn some CP/M apps.
3. Get TurboPascal or something and write & compile some Pascal code on CP/M.
Taking a year off with no income and studying something that doesn't directly lead to a job will increase OP'e anxiety.
Instead OP should do job, and might want to cut back on other activities for learning these.
A good old book will help, (EG) look at: Digital Logic And Computer Design - Morris Mano (free pdf at archive.org)
Semtech has some dev boards and tutorials for connecting to Lorawan. Notably it all seems to just work if you follow the directions. Not true for a lot of other development boards and software.
If so, I second Gibbon1's:
> just do a few embedded projects.
Easiest entry: download a simulator for microcontroller (family) you have in mind. One that lets you single-step through assembler instructions, see effect on registers, CPU flags, memory contents, I/O pin state, etc.
Get 'close to the metal': eg. grab an Arduino + USB <-> JTAG (and/or serial) thingie, download IDE, work through "blinkie LED" example project.
From there, explore some of the integrated peripherals & what you can do with those:
Pulse Width Modulation (both in hardware, or software) as a kind of poor man's analog output.
Hook up character LCD display. Or graphic one, and code some mini games a la "snake", tetris or the like. A few I/O pins, buttons, couple of lines assembly code & presto! You've built a joystick from scratch.
Hook up sensors, relais, or some sensor network LAN stuff, etc etc.
WHATEVER seems interesting. Once you've done a number of such projects (and written a decent amount of assembly code), write some small C programs for the microcontroller, and see what assembly code it's translated into. Or write a small Forth system. See how such things change your perspective from programmer -> low level hardware.
From there on up, it's just layers upon layers of (mostly arbitrary) abstraction. Some 'invisible', some with a huuuge performance cost.
Quad core x86-64 is just a really fast 8051 with more & wider registers + bigger instruction set + huge amount of RAM. ;-)
Then read CS: APP.
Many will suggest nand2tetris. But many people I know couldn’t keep up with it.
I finished it with much struggle. If you are a self-taught front-end dev, it’s quite likely you are not going to be able to finish it.
Quick read about what what CPU is compatible with what motherboard then selecting memory and sufficient power supply.
You have 6 main components.
-Case
-Power supply
-Memory
-CPU
-Motherboard
-Hard Drive
I'm really surprised someone on HN would feel like it is a challenge.
* making sure the motherboard supports the CPU via socket and also nominally
* making sure the heatsink can be mounted on top of the CPU socket
* having the case fit your motherboard form factor
* if there is a dedicated GPU, making sure it fits inside the case and there is a PCI-E slot with sufficient lanes for it
* if not, making sure there is an integrated GPU
* selecting a PSU that can handle the maximum power load for the GPU and that has a power cable for the GPU if it needs one
* making sure to buy the right type of ram in accordance with what the CPU and motherboard support
* if you want wifi, making sure there is built-in or there is a m.2 slot for wifi
* if you want a m.2 NVMe SSD, there should be a m.2 slot with the right key interface
Not often you end up buying parts that don't work well with each other and need to buy other parts. I once bought a small factor m.2 ssd only to discover it didn't fit the slot. I think it was trying to fit an M key device into a B key slot. Sometimes even the vendor data can be incorrect.
It's really not necessarily that hard -- I say this not as an insult, but as an encouraging clue that whatever documentation or technique you followed last time you tried may have been overcomplicating things -- it can be about as easy as putting legos together.
So, if building your own PC from off the shelf parts (which is quite different from what the poster is talking about actually) is something that interests you, I would strongly recommend not giving up and assuming that it's too hard for you, and instead concluding that whatever resources you used last time to guide you are inadequate or aimed at a more complex goal than you need.
I can't give a specific recommendation since I haven't done it in years, but you really just need to pick out a case (which usually will include a power supply), motherboard, CPU, RAM, and hard disk. To make it easier, avoid needing a CPU and just get a motherboard that includes the CPU. (Same goes for GPU) Then, ensure the motherboard is compatible with the case, the RAM is compatible with the motherboard, and the hard disk is compatible with the motherboard. Finally, total the power usage for each component and ensure it's less than the power supply's power output. Honestly, this compatibility planning is the "hard" part, once you get the components it's just plugging them into each other in a logical way, it's not like decades ago where you had to fiddle with jumper switches and the like. For your first time, you can also just set your expectations low, make sure you get things with good return policies, and return components if you end up being mistaken about their compatibility, but this should not be an issue if you read their specs carefully.
You can even buy kits that already include parts known to be compatible. Or for example, bundles that include the motherboard and some compatible RAM -- if you get one of those all you really need is the case and you're done (Since technically, the hard drive is sort of optional, if you always boot from a live USB or netboot image!)
NewEgg.com used to be great for this kinda stuff years ago, although I've heard they've "gone downhill"? No idea
Or even further towards ease, take apart your PC and put it back together.
That said, lol, you're right, this is something for most people you do once, and it was cool, but next time you just buy off the shelf to save time. There was a time when you could save a lot of money building your own but that time is long past.
It nicely combines software and learning computers!
Another option is to write an emulator for a simple ISA like PICO8 or for a device like the Gameboy.
EDIT:
Looking up the course you mentioned it seems like it's intended to cover similar terrain as Nand2Tetris but doesn't have nearly as much material available or a reasonable timeline. Is this https://github.com/geohot/fromthetransistor really all he has posted? I'd definitely recommend Nand2Tetris first, it consists of 12 projects. It can be reasonably completed in 12 weeks of part time effort and then you can take that as a jumping off point into fuller treatments of the topics that catch your interest or where you find yourself with an obvious gap in knowledge.
Also this concerns me:
Section 4: Compiler: A “high” level language -- 3 weeks
- Building a C compiler(Haskell, 2000) -- A bit more interesting, cover the basics of compiler design. Write in haskell. Write a parser. Break this into subchapters. Outputs ARM assembly.
- Building a linker(Python, 300) -- If you are clever, this should take a day. Output elf files. Use for testing with QEMU, semihosting.
- libc + malloc(C, 500) -- The gateway to more complicated programs. libc is only half here, things like memcpy and memset and printf, but no syscall wrappers.
- Building an ethernet controller(Verilog, 200) -- Talk to a real PHY, consider carefully MMIO design.
- Writing a bootloader(C, 300) -- Write ethernet program to boot kernel over UDP. First thing written in C. Maybe don’t redownload over serial each time and embed in FPGA image.
If you know Haskell enough to make a compiler, Python enough to make a linker, C well enough to make libc + malloc + a bootloader, Verilog well enough to make an ethernet controller all in three weeks, then you don't need this "course" at all. Just the C compiler in Haskell part is a semester long academic course, and rarely actually results in a full compiler with a teacher setting the pace (with assignments, quizzes, and tests).
The second half is more software-oriented: you start by writing a stack machine emulator for your computer, and then you write a compiler for an object oriented high-level language that outputs stack machine code. Finally, you write a standard library for your language.
As a third part to this course, we will then implement that computer on an FPGA, following Michael Schröder at https://gitlab.com/x653/nand2tetris-fpga/ . This will be my first experience with FPGA development, so I'm looking forward to it as well.
Ground up this video is fantastic and shows why first computers were made from lightbulbs: https://youtu.be/FU_YFpfDqqA
Top down you'll to want to start working with a lower level language, if you're confident with languages like Java, start looking at C, particularly pointer arithmetic which reflects memory locations. From there look at how drivers work - C on an Arduino for example to control electronics. This is simpler in some ways that trying the equivalent through many framework abstraction layers you don't need to know about on a PC. This teaches you registers, byte and memory manipulation to control hardware, as well serial data transfer technology (low level data transfer protocols over a wire one which modern USB is based). It also helps with your understanding for how some hardware such as a GPS you can literally read NMEA (coordinate) data as a string over a serial port/USB connection https://en.wikipedia.org/wiki/NMEA_0183 . This was an eye opener for me ~20 years ago.
Going down from the level of memory and byte manipulation you get to assembly language, which tends to be machine/CPU specific operations but will teach you the architecture side of a computer, and depending on the arch you learn align with CPU instruction sets (as well as basic copy memory type ops, modern CPUs have SIMD instructions, e.g. MMX or hardware encryption etc). You can go slightly lower here to microcode but the gains would be minimal in advancing your general knowledge.
Lower from there you need to consider how the components are made and their electrical properties, e.g. flipflops, CPU parts like ALU etc. You're then pretty much at the ground up stage so the video above shouldn't be an eye opener...
Then to test your knowledge end to end... write an emulator for something like a Gameboy in Javascript :D
https://imrannazar.com/GameBoy-Emulation-in-JavaScript:-The-...
"How a computer works" is very broad, and covers a lot of different disciplines. Like everything else in computing, it's layers of abstraction, and there's a lot of depth you can go into at any level. What you're describing is basically an ECE undergraduate curriculum, but it's very possible to get a "tour" of various layers in less time than that without going to school for it.
There's a lot of different ways to approach learning, and the bottom-to-top tourist approach is certainly one way to do it. I personally would not recommend it, as you're going to run into lots of different concepts that will take time to digest, and some of the tooling will be rather opaque or foreign, without a mentor to guide you. Another approach would be top-to-bottom, where you do some C systems and kernel hacking and work your way down from there. If you the art of programming and Computer Science, that might be a better fit, but there's also lots of arcane stuff in Linux and x86 that can be demotivating. The approach I advocate is usually the "maker" one, where you hang out in embedded systems land, and come up with projects you want to make. The benefit of embedded projects is that your projects will be physical things that interact with the real world (which may or may not be actually useful). That lets you explore a breadth of topics as needed, but is a bit adjacent to your goal of "knowing how a computer works".
Re: geohotz's curriculum, have others actually done his course? The curriculum looks interesting, but laser focused on bringing up a CPU in Verilog and bootstrapping the OS in C. I'm not sure how easy the course would be without at least some Verilog and systems programming background. 12 weeks seems very aggressive, and you're gonna end up missing concepts if you try to do it at that pace. The course I usually see recommended is nand2tetris, but I haven't tried it myself.
For foundational curriculum, I would probably recommend:
* The CSAPP Book (https://csapp.cs.cmu.edu/) - The introductory systems programming book/course. The labs are really good; do them! You could probably spend a year just with this course and come away satisfied. It'll have you interfacing with computers in C, learning about how cache works, writing your own malloc, doing some networking code, etc.
* Circuit Design - Optional, but some electronics knowledge doesn't hurt, depending on how far down the stack you want to go. Don't need to go into the fancy stuff, but should at least know enough of the basics to understand how transistors work, and how they can be used to form gates.
* Digital Design / FPGA stuff - I don't have a good rec for this. Nand2Tetris? There are some interesting projects out there that make FPGAs more accessible, like fomu and the reverse engineered open lattice toolchains.
* Computer Architecture by Hennessy & Patterson - Guides you through the concepts of a CPU, and has you writing your own MIPS CPU in Verilog. ARM is cool and all, but for a toy CPU, MIPS is a little more manageable, IMO. If you try to go straight to comp arch without some base level of digital design/FPGA/Verilog experience, you will probably have a bad time or end up with some gaps in your knowledge.