This is an invitation-only class. If your child has been invited to take it is because s/he showed interest in STEM, mastered some basic principles in the programming class, and exhibited a behavior in class that gives me some confidence that s/he will also behave in this class. Other than this, the class has no prerequisites.
This is not a class about how to design with a computer; it is a class about how to design a computer. This is the first time that I am teaching this class so I do not know how far we will get but given that it is a single session per week, without reading material or homework, I expect that it will take no less than a year and probably longer. Still, as long as the children are learning and having fun, this does no bother me.
The material that we will see is studied in detail in different college classes. However, we will only use the bits and pieces needed to plow forward. The idea is to learn how to build a computer, moving forward as follows:
- from Circuits/Electronics: voltage, current, basic electronic components (resistors, LEDs, transistors); reading and assembling circuits.
- from Logic design: boolean logic, truth tables, logic gates, synthesis of logic functions
- from Logic Design: simple combinatorial circuits, Nand-based gates, multiplexers, demultiplexers, Hardware description Language (HDL)
- from Logic Design: binary system, not-so-simple combinatorial circuits: half and full adders, incrementers, the Arithmetic Logic Unit (ALU)
- from Logic Design: sequential circuits: clocks (ring-waveform generators), D-flip-flops, registers, Random Access Memories (RAM)
- from Microprocessors: low-level languages, BASIC’s goto-logic, machine language (ML), assembly language, mnemonics
- from Computer Arch.: the Von-Neumann architecture, the program counter (PC), RAM and ROM, the Central Processing Unit (CPU)
- from Languages: symbols, symbol tables, parser, 2-pass assembler
At this point we will have a computer that can run a program written in machine language. This is as far as we can get w/o stronger prerequisites on programming. A follow-up to this class, that does require some programming skills (e.g., those acquired in Intro. to Programming II), includes:
- writing a virtual machine that translates virtual machine programs into machine language programs
- writing a high-level language that translates high-level programs into virtual machine programs
- writing a game in the high-level language
The two classes together pretty much teach how to design a computer similar to a ‘gameboy’. But let’s go back to the first part of the class, which is what we are offering right now.
If you are an engineer or computer scientist you might appreciate the beauty of this class: it is an end-to-end view of how a computer works. Electrical engineers, for example, are exposed to all the hardware portion of this class and are comfortable programming, but have no idea of how to write a computer language. Likewise, computer scientists are familiar with computer language design (e.g., compilers), but have very little exposure to hardware. This class covers it all, although, granted, without a lot of depth.
The idea for this class comes from two books:
Petzold explains how to build the hardware of a computer starting with relays; Nisan and Schocken do the same thing but starting with NAND gates and go beyond Petzold, finishing the job with all the associated software. In particular, the text by Nisan and Schoken is used for a semester-long (4-months) computer science class that can be taken at any level, at undergraduate entry level, like in Stanford and Harvard, or graduate level, like in the Univ. of Chicago; at any level the students can take this class w/o any prerequisites other than basic programming. Still, even at entry level, we find that the students taking this class are usually highly motivated college-level ones, so we need to go much slower with our highly motivated PCR elementary-level students: instead of taking 4 months to go over both the hardware and software portions, we are budgeting 1 year for just the hardware part (for which there are no prerequisites).
In Nisan and Schoken’s site, they document that the youngest student that followed their material to design a computer is 11 years old Saad Nasser; still, bright as this child is, he had the guidance of an engineer. This is, indeed, the case: although it is true that this material has no prerequisites, it is also true that it would be extremely difficult for a newbie, regardless of age, to tackle it successfully without some guidance.
My intention is to have a hands-on class; a small lecture, some handouts, and then a lab. The class will take place at the computer lab both for the lectures and the lab sessions on circuits, transistors and logic gates; each student receives a breadboard, together with batteries, battery holders, LEDs, transistors, resistors, wires, and logic probes (actually we build our own logic probes… it is our first project).
We will also use the computer lab for the sessions on logic circuits and beyond, when we will be designing components with hundreds to millions of transistors; at this time we will switch from the breadboards to hardware design in the same way that it is done at AMD or Intel: with a hardware emulator that runs a hardware description language similar to VHDL or Verilog.