Slashdot Mirror

No, start from scratch for real: Nand 2 Tetris

Some good beginner computer architecture books:

Code by Charles Petzold
Inside the Machine by Jon Stokes
Machine Language for Beginners by Richard Mansfield

And an online course:
NAND to Tetris

Except the article's analogy is pants on head retarded.

It's trivial to learn how to develop film in a dark room. My highschool had a Photography class as an elective, and children learned how to develop the film and take neat pictures, even do compositing and other effects. We even made our own photosensitive chemicals and plates and took pictures with pinhole cameras so we could do the entire photographic process 100% from scratch.

No one knows how to develop a digital photograph. Snapping the picture is not the same as developing the picture. That's the same as using a camera with a roll of film. Any idiot could do that with digital or film, it's still point and shoot, maybe adjust a lens for focus or fstop for lighting, but that's simple shit and you have fstop and manual focus on digital cameras too.

The article is wrong because the full chemical photography process can be done by highschool children. However, high-school children aren't going to learn microprocessor design, lithography to make ICs, create CMOS and write an assembler from scratch for the BIOS / Firmware. Implement C (or Forth first for bootstrapping, because it's smaller). Write image processing software and implement JPEG standards along with USB and SD Card drivers and all the other bullshit it takes to get a single digital photo from scratch and into your other hardware.

Nand to Tetris is the closest we have to that, but it doesn't cover all the bases in terms of software design, OS design, hardware interface implementation, etc. While SOME highschool children can pull it off, those are going to be a very small minority and most kids will be lost as fuck, fail, or so bored they'll sabotage themselves instead.

Coding isn't for everyone, just like Nursing isn't for everyone, and Varsity Football isn't for everyone. Humans specialize. This bullshit where we try NOT to specialize is destroying education, on purpose BTW. If you want coding in school you just need to make it available and have ZERO CURRICULUM, like the Sudbury Schools, where kids are free to work at their own pace and learn whatever they want whenever they want. This is better because kids learn different things at different rates at different times in development. We're all unique individuals. The old kids can hang out with the younger kids while they teach each other the skills they discover. Their grades are better than the graduated public school with "standardized testing" method.

This is what you sound like to me:

OK, so I don't know much about programming and stuff but I still can't understand how you create $VIDEOGAME without a game engine. Apparently the $VIDEOGAME was written in pure C. How can you achieve such a thing?

That is to say, just as you can create a game via leveraging prebuilt functions of an existing engine or write the code yourself in $LANGUAGE, you can create $PROGRAM via leveraging prebuilt functions of $HARDWARE or design the dedicated hardware itself to perform the logic. We also had 3D graphics before hardware accelerated triangle rendering boards too. Specialized hardware/software platforms can be useful (especially if processing or development time is a bottleneck) but they are far from necessary. In fact, I often find them limiting and/or wasteful.

E.g.,with a software rasterizer instead of GPU rendering pipeline I only needed one copy of the geometry in memory at a time, and the input/network/physics functions can operate on the same geometry data as the rendering system uses; Contrast that with having an asset manager to shovel data across the tiny graphics bus, and often keeping two or more copies of 3D data in memory: One for physics on the "CPU" side, one for rendering on the GPU side of the bus, one for network state updates and lag-compensation (because functional programming lends itself to batches, and multiple cores exist). With a fully programmable pipeline (yay geometry shaders!) we're finally getting back most of the freedom we had back in software only rendering. With shared memory architecture we're finally getting back most of the freedom we had in CPU side only rendering. Perhaps with something like faster reprogrammable FPGAs we'll finally get back some of the freedom we lost to CPUs when we migrated away from ASIC. Well, the game cartridges COULD have their own logic and data, and other custom circuits, but they weren't really ASIC since they could provide input devices too, see GBA games with photocells to change the game world to match your environmental light or with mics, or carts with save functions built-in made for consoles without data storage, etc.

You see, someday when we're forced to 3D print all our own chips because of the Ken Thompson Hack (which indicates we can't trust any software or hardware stack one didn't create oneself) we'll finally have back the freedom to create video games we once had when the game wasn't restricted to running on existing (read: shitty/limited) hardware.

TL;DR: Would you like to know more?

I'll just leave this free and open source CS101 course here: NAND to Tetris.

Why do we not hear more about nand2tetris.org and the wonderful work Mssrs Nisan and Schocken have done? They teach computing concepts from first principles, and in a way that's fun and engaging. I say this is perfect for introducing a gifted youngster to the wonderful world of computing.

http://www.whywork.org/rethinking/whywork/abolition.html

As a software developer, in some ways I think we hit a peak with languages like Smalltalk, Common Lisp / Symbolics, Erlang, and C in the 1980s and an OS / VM architecture like IBM's System 360 and VM (which was in a sense "open source" till the mid 1980s) and things have been sliding backwards ever since. I learned C around 1983 on Unix (VMUTS) running on VM hardware (on an IBM mainframe with two CPUs where typically when I did a compile VMUTS got one CPU and 100 I/O bound users shared the other, giving me ten a second turn around for "hello world"). VisualWorks+ENVY in the late 1980s was just amazing for its times, solving issues in practice that Java and Eclipse in practice still struggles with on 1000X faster hardware. That all could have just gotten less expensive, faster, and grown gradually, and become more (not less) open. See also: "VM and the VM Community: Past, Present, and Future"
http://www.leeandmelindavarian.com/Melinda/

The reality is, in the US marketplace, people usually create incompatible "standards" on purpose to gain vendor lock-in, or to make some marketing claim, or to work around some copyright or patent. As with Microsoft in the past, companies may intentionally try to sabotage standards (embrace, extend, destroy) as an example of market failure relating to monopoly and externalities. Still, another reason this happens is that creating new things from (seemingly) scratch can be a lot of fun (even as almost everything is built on layers of past work, including notions of physics).

I'm all for experiment and diversity, and I'm all for plug-in modularity, and I'm all for learning-by-doing including through building systems from the ground-up (e.g. http://www.nand2tetris.org/ ). But, practically speaking, our bigger problem these days is mostly too much software, too many standards, too many programming languages, too many libraries, too many IDEs, too many OSes, too many drivers, too many plugins, and too many applications (all with too much accidental complexity). Instead of having a few comprehensive reliable (and free and open source) systems implemented in the above languages and using a common VM standard, we have many half-made buggy ones. This is not to say those languages above could not be improved or that another addition to them would be bad. It is just that at some point a plethora of half-finished choices is its own kind of oppression.
http://en.wikipedia.org/wiki/The_Paradox_of_Choice:_Why_More_Is_Less

See also:
http://www.t0.or.at/delanda/meshwork.htm
"To make things worse, the solution to this is not simply to begin adding meshwork components to the mix. Indeed, one must resist the temptation to make hierarchies into villains and meshworks into heroes, not only because, as I said, they are constantly turning into one another, but because in real life we find only mixtures and hybrids, and the properties of these cannot be established through theory alone but demand concrete experimentation. Certain standardizations, say, of electric outlet designs or of data-structures traveling through the Internet, may actually turn out to promote heterogenization at another level, in terms of the appliances that may be designed around the standard outlet, or of the services that a common data-structure may make possible. On the other hand, the mere presence of increased heterogeneity is no guarantee that a better state for society has been achieved. After all, the territory occupied by former Yugoslavia is more heterogeneous now than it was ten years ago, but the lack of uniformity at one level simply hides an increase of homogeneity at the level of the warring ethnic communities. But even if we mana

As an aside, if there are any other young-ish programmers out there who have been looking for good introductory material to the low level workings of computers, I would encourage you to check out this course. The course includes the first six chapters of the text book, Elements of Computing Systems for free, but you'll have to purchase the book (or obtain it in a more questionable manner) to continue past that. The book begins using only NAND gates as a primitive, and guides you through assembling all of the logic gates you need for a CPU. Through the whole course you design your own gates, CPU, operating system, assembler, compiler, and end up with a software emulated system that you can write applications for. It never really tells you what to do, it gives you the knowledge you need and then lets you figure stuff out on your own.

I'd agree with Joe_Dragon that apprenticeships can make a lot of sense. Your post makes me think about something else, putting a few factoids together in a new way. I'm thinking, speculating a bit from what I saw in academia the 1970s and 1980s, that there was a time, decades ago (like before the 1970s) when academia was growing so fast (exponentially) that people from industry without PhDs or much anything beyond real knowledge could become well-respected reasonably-paid teachers (unlike today's somewhat disrespected and poorly-paid adjuncts). In the 1970s, exponential growth of academia stopped (as David Goodstein points out). So, at that point, there came a glut of PhDs on the market with few job prospects since academia kept churning them out at a rate appropriate for exponential growth that was no longer happening. Working conditions for most new faculty plummeted (supply and demand). It became impossible to get even a mediocre college teaching job without a PhD (or at least a Masters for lesser schools). So, academia over the last couple decades became staffed with *only* academics with little real-world life experience which it generated internally. The two-way interchange between industry and academia became essentially one-way, academia to industry. Add to this in the USA the loss of the family farm, loss of good hands-on union mechanical/electrical jobs with apprenticeships, the expansion of the school year, and the increase of opaque black boxes in industry, and the result is few entering academia had any practical non-academic experience or had any way of getting any (like by summer jobs). This of course is all a bit of an over-simplification, yet is may explain why courses are less useful now? References:
http://www.its.caltech.edu/~dg/crunch_art.html
http://en.wikipedia.org/wiki/Disciplined_Minds
http://philip.greenspun.com/careers/women-in-science

More links here:
http://p2pfoundation.net/backups/p2p_research-archives/2009-October/005379.html

See also my: http://www.pdfernhout.net/post-scarcity-princeton.html

Bottom line: most real education is "self-directed education", whether it is in the garden, in the shop, in the library, or in the "classroom". However, self-directed does not mean we do not learn much from other people, whether face-to-face or through their writings or recordings. Thus, you learned from people who wrote the textbooks, even if the "teacher" you say regularly face-to-face may have had little to offer.

You may be beyond this, but this is probably a good way to learn computing almost from the ground up these days:
http://www.nand2tetris.org/

Or one can build programmable computers from Redstone in Minecraft? :-)

It sounds like anyone who teaches optimization by teaching assembly probably does not know much about optimization, since assembly is just a distraction from it, especially given today's compilers can generally write better assembly for most CPUs than most programmers ever could. The real optimization challenges are in algorithms, thinking about prioritization of values and managing complexity (of both data and implementations)...

Nand-to-Tetris is a bottom up book. "Data and Reality" by William Kent is a complementary book that is in-a-sense top-down:
http://www.bkent.net/Doc/darxrp.htm

I'd also recommend playing around with Forth (or a latter day equivalent like "Joy") to get a good sense of factoring problem well.
http://en.wikipedia.org/wiki/Joy_(programming_language)

My kid st

Well, there's multiple levels of abstraction in any applied science, and you've chosen your preferred "base" level. But remember that people like the guys behind from NAND to Tetris don't feel that your level of abstraction is the correct base either. But they've chosen a base level of their own that they define as "computer science" beyond which there is only "physics".

Lower levels of abstraction are good for building up background knowledge, but how deep you go really should depend on what your audience is expected to produce.

Although I would guess from your description that these aren't potential devs, just people "toying" with code, so they shouldn't be dealing in anything big enough to require an IDE anyway...

It sounds like you were able to avoid some of the more common pitfalls. Kudos on that. I was always pretty sure I'd stay on the individual contributor path, climbing the technical ladder and writing code for the rest of my career... until I wasn't. At one point, I got a taste of management and became hooked. It rivaled the feeling I got 20+ years ago when I wrote my first program in AppleSoft BASIC and filled up the screen with random colored boxes... I felt like a master of the universe. As much as I have enjoyed commanding electrons to do my bidding, leading a team of talented individuals and pushing them to exceed their perceived/self-imposed limitations, and accomplish something as a team that you never could have done yourself, has also been very rewarding and pushes me to expand my expertise beyond my comfort zone. Now that I only really write code for fun, I think I enjoy it even more than I did when I was getting paid for it.

The other day, I came across a site, http://www.nand2tetris.org/ that is a free course on computer architecture. In it, you build up a computer system from simple Nand gates, up through an ALU, CPU, Memory, and then the entire software stack, from machine code, assembly (via an assembler), high-level code via a compiler, etc. I took a course like this in college and it was another great "Aha!" moment for me where the connection between software and hardware (and eventually the basic physics of semiconductors) all came together for me. It was great to work through the hardware part of this course again (I got through it in an afternoon, but I was pretty addicted once I started). Give it a look, I think you'll enjoy it.

There's actually a really fantastic chart in Chapter 1 pg. 10 that I magnified and printed out as a quick reference. I also drew the gate pictures at the top so I could more easily interpret the schematics.

Slide 4 on the intro is wrong, Pong came out in the early 70's, in the 80's we had the Z80 and the Motorola 68000 in most of our arcade games. http://www.nand2tetris.org/lectures/PDF/lecture%2000%20introduction.pdf