54 of 57 people found the following review helpful
- Published on Amazon.com
The book is an exploration of it's title: A one-line BASIC program that was intended to run on an early 80s Commodore 64 computer. The program produces the maze-like pattern shown on the book's cover, and inner sleeves.
Each chapter explores a different facet of this program, and by doing so it covers an incredible amount of ground. There is a chapter on mazes, a chapter on randomness, a chapter on grids, a chapter on the BASIC language, and so on. If you think this is a lot of pages to devote to a one-line computer program, you are mistaken. The book barely scratches the surface of each of the diverse subjects it touches upon, from Falcon looms to flying toasters. There have been many books written about mazes, and whole careers built upon studying randomness, and this is a short little book.
It is the surprising depth and far-reaching ramifications of little useless programs like these that got me into this game, back in the early 80s. After my Timex Sinclair, my second computer was a Commodore VIC 20, the precursor to the more successful C64, and I fondly remember writing one-liners like these, staring into the glowing phosphors of a little television, until I could barely keep my eyes open in the early morning light. During the months that I manipulated those phosphors, the symbols they represented were manipulating me. My fevered brain underwent more intellectual growth during that period than any time in my life since my early childhood.
The book was written by a team of what my colleagues call "unicorns" - cross-disciplinary people who straddle the worlds of creativity and technology. I was expecting a set of disconnected essays from different voices, but I didn't get it. The authors used a Wiki to collaborate, and the book feels as if it were written by a single, extremely erudite author. The chapters cover separate subjects, but the whole is very much connected, helped by it's extremely constrained subject - that single one line program. Although the book necessarily describes some technical subjects, it is written for a lay audience.
I think of myself as a unicorn. There are a lot of us out there, but we are not as common as I would like. My feeling is that unicorns provide an important bridge between the liberal arts and the physical sciences, and that unicorn skills should be nurtured. All of my professional career, I have obsessed over a set of subjects which were, until recently, not given sufficient attention in the computer science press.
For example, I've always been fascinated by the RND() function in the BASIC language - I initially thought it was the most important feature of the language. For a long time, the amount of joy I derived from writing software was proportional to the amount that the software depended on randomness. There is a relationship between the RND() function and the perception of utility. To me, programs that are useful, and that do not require randomness, are boring. The RND() function is like a firehose from God, and the programs that use it are fun. They are games, and simulations, and art.
So, as an auto-didact (as many unicorns are), I was surprised that in programming texts that describe programming languages, the RND() (or rand() or random()) feature is always given such brief treatment. I've even met programmers who (gasp!) have never used it! Meanwhile outside of programming language texts, the topic is barely discussed. It's not a topic that non-programmers have been exposed to. To me, it's the first thing you should learn as a neophyte programmer. Yet so many computer science students are not exposed to it early enough - instead, they are compelled to write functions which factor numbers and do other numeric manipulations. Many programmers have thrived in this sterile environment, but it doesn't suit unicorns.
It is the love of RND() that separates this particular creative coder from your dyed-in-the-wool computer science nerd. At this late stage in my creative programming career, I no longer make as much use of RND() - I've discovered new ways to achieve the same important thing it gave me: complex and beautiful behavior with very little effort. The holy grail of the unicorn is the perfect one-line program. The one-line program that succeeds in recreating the universe, and making it's own DNA, and breeding with itself so that a new sub-universe is born. This is our philosopher's stone.
Another feature of unicorns is that they don't mind using programming techniques that are no longer on the list of officially approved methodologies by the software engineering orthodoxy. Incantations are only a means to an end. We are not in the business of making incantations, we are in the business of making universes, using incantations as a tool. 10 PRINT, for example, contains a GOTO command. GOTO, of course, has been the bane of readable code almost since the second edition of "The Elements of Style", and the BASIC language itself sits on a lowly plain of derision slightly above COBOL. The book also addresses the unfortunate gulf between recreational coders and the computer science establishment.
Unfortunately, one line programs, like unicorns, have become an endangered species. Those of us who remember one line BASIC despair at the new hurdles that have been raised, which prevent young people from discovering the joys of the random number generator. When we expunged GOTOs from the reserved words of all the new programming languages, when we made our code structured, object-oriented and useable for large complex software engineering projects, we also made it much harder for kids and teens to use those same technologies to explore the imaginary landscape. If the first programming language I had been exposed to was Java, I think I might have ended up in a different profession entirely.
The proceeds of this book go to PLAYPOWER - a charity which aims to give disadvantaged kids access to extremely cheap computers that have a one line BASIC. This seems like a wonderful thing. Damn, I want one of those computers too! I miss my VIC 20.
10 of 10 people found the following review helpful
- Published on Amazon.com
I rated this a five because it does what a collaboratively written book should do: The analyses of each element are deep and thoughtful and each author is really able to drill deeply into the subject of computer programming with the best tools of their respective disciplines. I've learned a lot from this book and I think it's a really good read for either engineers/programmers with an artistic side and liberal arts majors with a technical side. There is just so much insight in this book I can't even begin to do it justice in this review. It has even made me a better programmer just because it provides background into how certain methods came to be and why things are the way they are. It's one of those books that leaves me feeling a lot smarter than when I started.
5 of 5 people found the following review helpful
- Published on Amazon.com
Short version: a great book that I'm surprised exists, that combines my interests in programming, classic computers, and art. Strangely, page 229 has lots of technical errors that probably don't matter to most people, but considering the precise and in-depth nature of most of the book, and that it's presented as an academic study, I think it's worth examining and correcting.
Long version (from my blog):
I should start this by saying I love the book 10 PRINT; reading it was a great way to start 2014 and inspired some of my own projects.
It was written by ten or so people, a smart bunch it seems. So I was really surprised when I was reading the chapter about the Commodore 64, page 229 in particular, to find several errors. I was even more surprised to find no one discussing these errors online, and the errors remain in the .pdf version available on their website as of this writing. I tried to contact a couple of the authors (Ian Bogost in particular, because I'm a fan and I found him on Twitter easily) but didn't catch his attention. I realize he's a busy guy. So I'll write about it, in the hopes it'll be corrected before the paperback version is released.
Error 1: "1,000 characters do fill the entire screen--in what might be considered an illusory consummation of the maze--before the text scrolls upward, leaving two more twenty-five-character rows to fill."
This should, of course, be "two more forty-character rows to fill". The Commodore 64 screen is 40 characters wide, and 25 characters tall; 1000 characters in total. When the screen scrolls upward, the bottom two rows are left empty, requiring 80 new characters of maze to be filled in.
Error 2: "While the code for 10 PRINT specifies one of two characters to display on the screen, it says nothing about where on the screen the chosen character should appear. That placement is defined by the VIC-II chip."
This statement is sufficiently vague that perhaps it's not in error, but to be clear: the VIC-II chip has no control over where a PRINTed character will appear on the screen in 10 PRINT; it simply provides the 40×25 character screen that BASIC accesses through the PRINT command, which in turn uses the C-64′s KERNAL operating system. Zero page locations $D6 (line number) and $D3 (column number) are used by the KERNAL to calculate where the character will be plotted in memory.
Error 3: "The large border that surrounds the maze is not addressable by the VIC-II; the thirty-two pixel borders on the left and right and thirty-five pixel borders on the top and bottom were created in consideration of the wide variation within cathode ray tube televisions of the era."
I'm guessing that these numbers were obtained from an emulator screenshot, but they don't at all represent what the VIC-II does. Depending on the version of the VIC-II, there are between 403 and 411 pixels visible per scanline (as per the famous VIC-II document); subtracting the 320 pixels of the 40 column screen, we're left with between 83 and 91 border pixels viewable, if your monitor/TV will show them. I don't know how they're split between the left and right sides, but as an odd number, it probably isn't evenly! The top/bottom values are also incorrect; the VIC-II (again, depending on version) produces between 234 and 284 visible scanlines per frame; subtracting the 200 pixels of the 25 row screen leaves between 34 and 84 potentially viewable pixels worth of border.
Error 4: "Running 10 PRINT in a software emulator, of course, eliminates the need for such a border, though the Commodore 64's KERNAL nevertheless draws it."
The KERNAL has no part in drawing the border; this is solely an automatic function of the VIC-II chip. Interestingly, through precise and active manipulation of the VIC-II's registers, the borders can be prevented from appearing, revealing sprites placed behind that area. This has been used in games to display information (such as scores) in otherwise unusable display space.
Error 5: "In addition to wrapping text automatically, the VIC-II also automatically scrolls the contents of the screen when the cursor is on the bottom row and attempts to move down."
The VIC-II plays no role in scrolling the contents of the screen in _10 PRINT_. That is done by the BASIC and KERNAL software.
I welcome any corrections to my corrections!
1 of 1 people found the following review helpful
- Published on Amazon.com
10 PRINT completely and entirely dissects its titular one line of code in every sense possible. Technically, aesthetically, historically. An excellent examination of an at-first seemingly inconsequential footnote of computing.
5 of 8 people found the following review helpful
D. R. Pitts
- Published on Amazon.com
I liked it - half of the book (at least) a lot of nice history of the early PC Scene, basic etc (very cool), but 50% felt like it was a parody of postmodernist interpretations of the cultural, artistic and philosophical, interpretation of the one line code. Making a mountain out a molehill.
I read it, skipped the bits I didn’t understand, enjoyed it, and passed it on.