From Maze

Proposed Chapter Overview

(in progress)

Goals

This chapter tracks BASIC as a language that has mirrored the development of computing, both technologically and socially. The main focus is on the C64/TRS-80/Early DOS era, but the meat of the chapter is sandwiched between two sections describing where BASIC came from before then and where it has gone since. While the chapter does talk about some aspects of the language itself, it is usually in the context of explaining why changes were introduced to BASIC over time in response to changes in development expectations and computing.

Structure

History: This section starts with Dartmouth BASIC and covers the pre-home computing era. While there is a description of the technological development of the language, the emphasis is really on how it became a widely implemented language (free compilers, pushes in education, etc.) Ends with 8080s and M BASIC. Introduces the early Byte magazines as a means of code distribution.

BASIC on the PC: Describes how BASIC got onto the Apple II, TRS-80, and PET, leading into the C64 and DOS. Looks briefly at the cross-platform similarities as beneficial to the language, but more at how BASIC acted as a continuation of the previous era's homebrew computing activity. Ends with the transformation of the workspace introduced by integrated text editors (like QuickBASIC/QBasic) and discusses how BASIC's iconic line numbers were dropped from the syntax.

BASIC in print: Explores the influence of Byte, Run, Compute!, etc. less on the programs themselves than on the people who typed them in and thereby learned BASIC and programming in general. This section ties back to 10 PRINT... by taking one-liners as an example of these methods carried to their extremes. Carries through to the development of diskmags like Loadstar and ends with BBS/online distribution, Doom, shareware, and OSS. This is the section where the case is made for BASIC kicking off a generation of programmers.

Legacy: Tracks where the language has gone since its heyday at the dawn of home computing. VB is strongly mentioned (along with a discussion of introducing objects, visual IDEs, etc.) but put into contrast with Mono and various niche implementations to pose the question of which version is the true legacy of C64 era BASIC usage and ethos. Suggests another type of successor in learning languages like Scratch, but also talks about the difference in using a language to learn programming and learning programming by using a language (ie, learning with intent vs. learning due to hands on use because the user wants to run a program).

Original Review

General Comments

I'm not clear on the connection between the two sections that would put them in the same chapter. What is the overall structure/goal? One seems like a sort of evolutionary history that explains how the language developed, and the other seems like a discussion on a historic means of implementation. While I can see the two co-existing, I don't have any clear picture of what the intent is here. Both sections need to have some sort of common thread introduced that can run throughout if they are to stay together, but I might move the Typography section to be a sidebar in the Token-by-Token Explanation and leave this chapter to expand on the 10 Print in Memory ideas.

10 Print in Memory

- The discussion of Doctorow's story combined with the subject at hand made me think also of an idea Vernor Vinge has used repeatedly in his writing, that effective programming is based in memorization of the domain as opposed to memorization of the language - that is, it is useful to know syntax, but more important to know that somebody else wrote the function you need five years ago and all you have to do is call it from the library. I wonder how that relates to memorization of 10 Print? As is mentioned in the text, the functionality of 10 Print is more social than computational, but (particularly at the time of the C64) it is useful to have a quick trick on hand when you want to show somebody what you can do by programming a computer. 10 Print's entire code isn't any longer than a function call in most languages; is memorizing it essentially a function call to a social library?

- While the memorization studies are interesting, I think they need to be related a bit more to 10 Print since there are some fundamental differences between it and the code in the studies (as is mentioned). Right now the text is "This type of memorization will have certain things in common with the type done in these memorization studies..." - it would be useful to expand on "certain things" a bit more than is done in the sentence after that one.

- I'd like to see more on the purpose and mechanics of transmitting code via print - as is mentioned, people are not really able to relate to it today, so more explanation may be useful (if it is not done elsewhere).

- I've not read the study, but was Schneiderman looking at memorization character by character or functionally? The text says the focus is on "comprehension", which seems like a different context than 10 Print - but it may be an opportunity to discuss the variations in 10 Print that different people have remembered.

Typography and Basic

- Interesting bit of teletype history that I hadn't come across before; is this also where CSV files came from? If so, it might be nice to mention that as well since at least some people are still familiar with them today.