HAckerzz Syllabus For CS Speed Run

For many of you aspiring to get admitted into universities for Data Science or AI/ML programs, the first question that comes to mind is what these fields actually entail and how challenging they are.

Actual Learning is hard. Many modern computer science programs are inadequate, making it difficult to find people who understand the computer stack from first principles.

Section 1: Intro: Cheating Our Way Past the Transistor (0.5 weeks)

• Overview of Transistors: Explain how FPGAs are constructed using transistors and that integrated circuits (ICs) are essentially collections of transistors in a reliable package. Introduce the concept of Look-Up Tables (LUTs) and related components. While we’ll touch on transistor theory, the projects will build on each other without constructing transistors from scratch.
• Emulation: Emphasize the limitations of real hardware and how using tools like Verilator allows anyone with a computer to participate.

Section 2: Bringup: What Language is Hardware Coded In? (0.5 weeks)

• Blinking an LED (Verilog, 10): Write your first program to blink an LED, get the simulator working, and learn the basics of Verilog.
• Building a UART (Verilog, 100): Introduce Verilog through the construction of a UART. Discuss Memory-Mapped I/O (MMIO), and implement a serial test echo program and LED control.

Section 3: Processor: What is a Processor Anyway? (3 weeks)

• Coding an Assembler (Python, 500): Write an assembler in Python to output binary files, running in parallel with CPU development. This will teach ARM assembly. Initially, the output will be binary files, later evolving to include a linker.
• Building an ARM7 CPU (Verilog, 1500): Break into subchapters covering a simple pipeline: decode, fetch, execute. Discuss memory requirements, aiming for at least 1MB of RAM, possibly SRAM.
• Coding a Bootrom (Assembler, 40): Develop a bootrom for code download into RAM over the serial port, integrated into the FPGA image, running basic test programs.

Section 4: Compiler: A "High" Level Language (3 weeks)

• Building a C Compiler (Haskell, 2000): Cover the basics of compiler design in Haskell, including writing a parser. Break into subchapters, outputting ARM assembly.
• Building a Linker (Python, 300): Develop a linker in Python to output ELF files for testing with QEMU and semihosting.
• libc + malloc (C, 500): Implement basic libc functions like memcpy, memset, and printf, excluding syscall wrappers.
• Building an Ethernet Controller (Verilog, 200): Interface with a real PHY, considering MMIO design.
• Writing a Bootloader (C, 300): Create an Ethernet-based bootloader for kernel boot over UDP. Embed it in the FPGA image to avoid repeated serial downloads.

Section 5: Operating System: Software We Take for Granted (3 weeks)

• Building an MMU (Verilog, 1000): Develop an MMU akin to ARM9, explaining TLBs and possibly a memory controller. Add initialization code to the bootloader.
• Building an Operating System (C, 2500): Develop a UNIX-like OS with user-space threads and basic syscalls (open, read, write, close, fork, execve, wait, sleep, exit, mmap, munmap, mprotect). Include a debug interface and break into subchapters.
• Talking to an SD Card (Verilog, 150): Develop hardware and a driver for SD card communication.
• FAT (C, 300): Implement a basic FAT filesystem.
• Init, Shell, Download, Cat, LS, RM (C, 250): Create initial user-space programs for system interaction.

Section 6: Browser: Coming Online (1 week)

• Building a TCP Stack (C, 500): Implement a TCP stack in the kernel, integrating the Ethernet driver and supporting networking syscalls (send, recv, bind, connect).
• telnetd: The Power of Being Multiprocess (C, 50): Develop a telnet daemon allowing multiple connections.
• Space Saving Dynamic Linking (C, 300): Explain dynamic linking and required changes to the linker.
• So About That Web (C, 500+): Create a text-based web browser using ANSI and terminal capabilities, dynamically linked for efficiency.

Section 7: Physical: Running on Real Hardware (1 week)

• Talking to an FPGA (C, 200): Write code for a USB MCU to bitbang JTAG.
• Building an FPGA Board: Design a board with FPGA BGA reflow, USB JTAG port and flasher, LEDs, reset button, serial port, SD card, and Ethernet port. Optional features include host USB port, NTSC TV out, ISA port, and PS/2 connector.
• Bringup: Compile and download the Verilog for the board, testing the full hardware setup.