Based on a recent thread on Logo, I went on a Logo book searching binge. I found this book series by Brian Harvey, and they indeed look interesting. Right now, I am awaiting delivery of Exploring Language with Logo, which I am really excited about. I admittedly don’t plan on using Logo but instead will use either F# or Racket to go through the book. It seems there were a lot of neat exploration books published with Logo. I wish this style of book was more en vogue today.
I knew this was going to be about Brian Harvey as soon as I saw the title. He was a wonderful presence on comp.lang.logo years ago and would even help struggling noobs with their Scheme questions on occasion. He is a very clear writer and his dedication to teaching is inspiring.
Definitely, and Brian Harvey's books go a long way to showing just that: Logo is a full fledged language with wonderful pedagogical value, as well as a neat tool for easy exploratory programming, possibly better than more modern options like Python that suck all the air out of the room right now.
I've always thought Logo syntax was not just easy but outright elegant. There could be a parallel universe where it continued to evolve into the de-facto-standard-scripting-language role Python has now.
REBOL was one of the first languages I learned. Some parts were super powerful and easy, but I remember struggling with some parts of the language. I can't remember what those parts were now.
Of all these compile to JS languages we see currently, it's a shame REBOL is not one of them. I might be tempted to pick it up again.
Probably the same thread or threads. There was a couple posts that all hit the front page in the past week or two on the same day. I actually still have Brian Harvey’s full book series you posted in my Amazon cart.
Here’s an interesting article that discusses the language book.
No problem! And thank you for this post! Maybe I should go ahead and hit purchase on Harvey's Logo book series now.
There's also another book called Visual Modeling with Logo: A Structured Approach to Seeing that I've ordered that looks very interesting as well. I was drawn in by the description:
*****
> Filled with striking illustrations, this book offers an exciting exploration of Logo graphics for designers, architects, liberal arts students, and other individuals who are interested in creative applications of computers.
> Visual Modeling with Logo introduces the programming concepts necessary for describing and manipulating some of the basic visual structures in the world around us. Logo is a language that encourages visual problem-solving and helps us expand our understanding of how we see.
> The book provides a wide range of exercises for investigating the many dimensions and component parts of seeing; it proceeds from the simple to the complex, using representative models based on circular grids, rectangular grids, Islamic designs, organic forms, and different spatial systems.
*****
There's a few others books in a similar vain that I've found too: Learning Mathematics and Logo, Investigations in Algebra: An Approach to Using Logo, and Exploring Logo without a Computer. Then of course there's Turtle Geometry: The Computer as a Medium for Exploring Mathematics.
I'm a big fan of books that use programming to explore other topics, and it seems Logo generated a lot of books like this. It's my own lofty dream to write my own series like these.
I'm one of those people who still remembers Logo as the turtle graphics introduction to computers for children thing.
Are there large, commercial applications running on Logo these days, or is it a hobby language? Can you provide a brief summary of the status of Logo today?
NetLogo is moderately popular today. I've seen it used in academic contexts for modeling cellular automata and agent-based simulations: https://ccl.northwestern.edu/netlogo/
Really, its just Lisp. So the answer is yes and there are many apps using Lisp. This (HN) is one. All travel website flight lookups are a Lisp system. And so is Grammarly.
Definitely check out Brian Harvey's and Jens Mönig's latest masterpiece: Snap!, a block based visual programming language with the full power of Scheme, but ease of use of Scratch and Logo, written in JavaScript and tightly integrated with web browser technologies and libraries (including Ken Kahn's eCraftToLearn AI Programming for Kids extension using Tensorflow).
>The National Technology Leadership Summit (NTLS) Educational Technology Leadership Award recognizes individuals who made a significant impact on the field of educational technology over the course of a lifetime. The NTLS consortium is a coalition of twelve national teacher education associations that collaborate to advance effective use of technology in schools. The NTLS Educational Technology Leadership Award is the coalition’s highest honor.
>Brian Harvey and Jens Möenig, working together, have had an impact on the field of educational technology that is as significant as any other. The origins of their work dates to development of the first computing language explicitly designed for children. In 1966 Seymour Papert, Wallace Feurzeig, Daniel Bobrow, and Cynthia Solomon created the programming language Logo. Logo, whose name is drawn from the Greek word for word, is both a technology and an educational philosophy. Its inception also resulted in the development of an educational community that exists to this day.
>Brian Harvey had the opportunity to learn from Lisp inventor John McCarthy and Scheme inventors Gerald Sussman and Guy Steele, among others, as a student at the MIT and Stanford Artificial Intelligence Labs. Throughout the 1970s he was a frequent visitor at the MIT Logo Group, and starting in 1981 he was part of design teams for microcomputer versions of Logo for the Apple II, the Atari 800, and the Apple Macintosh. A high point of his career was establishing the Computer Department at the Lincoln-Sudbury Regional High School, in Massachusetts, offering ungraded courses that attracted a community of kids with keys to the lab and the responsibility for making the facility meet everyone’s needs.
>In the 1980s he wrote the three-volume Computer Science Logo Style, published by MIT Press. These books showed that Logo could be used beyond elementary school to introduce serious computer science ideas to a broad and diverse audience. He subsequently taught at the University of California, Berkeley, where he was recognized with the Distinguished Teaching Award, the university’s most prestigious award for teaching. He was lead developer of Berkeley Logo, which because of its status as free software has become a de facto standard for Logo implementations. Since 2013 he has been Teaching Professor Emeritus.
>On a parallel track, Jens Möenig collaborated with Alan Kay, inventor of Smalltalk, and worked with colleagues from the Xerox Palo Alto Research Center (PARC) who invented personal computing. He subsequently contributed to development of the block programming language Scratch, one of the languages influenced by Logo.
>Brian Harvey and Jens Möenig then embarked upon one of the most productive collaborations in the history of educational computing, jointly developing the block programming language Snap! The Snap! reference manual notes, “The brilliant design of Scratch, from the Lifelong Kindergarten Group at the MIT Media Lab, is crucial to Snap!.”
>Snap! makes advanced computational concepts accessible to nonprogrammers. Brian Harvey notes, “Languages in the Logo family, including Scratch and Snap!, take the position that we’re not in the business of training professional computer programmers. Our mission is to bring programming to the masses.” The Beauty and Joy of Computing, tightly integrated with Snap!, does just that. This curriculum, developed at the University of California at Berkeley, is notable for attracting equal numbers of male and female students.
>The course is approved for Advanced Placement credit by the College Board. With support from the National Science Foundation, professional development has been provided to more than one thousand high school computer science teachers. One computer science teacher who introduced the curriculum in his high school reported that, “Before using Snap! and the Beauty and Joy of Computing curriculum, I had one section of computer science with 17 students. Three of the students were girls. Now I have three full sections of the course with equal numbers of male and female students.”
>Snap!, provided as free, open source software, has inspired development of many extensions. Among others, these include environments such as Snap4Arduino, which supports work with microcontrollers and robotics; mathematics microworlds for elementary children developed by Paul Goldenberg and his colleagues at the Educational Development Corporation; and iSnap, an extension developed by Thomas Price which suggests hints to students based on the work of other students. Another extension, TuneScope, designed to facilitate exploration of coding through music, is being developed by a collaborative team at the Society for Information Technology and Teacher Education (SITE).
>Snap! is a remarkable technological achievement. However, like Logo, its greatest achievement is arguably the educational philosophy that it draws upon and supports, and the associated community drawn together by this philosophy. In a very real sense, the Snap! community embodies the spirit of the early Logo community, extending it for the modern world. The NTLS Educational Technology Leadership Award, awarded to Brian Harvey and Jens Möenig, is presented in recognition of that accomplishment.
Snap! is not simply all the usability and functionality of Logo, but also all the functionality and power of Scheme! Without any of the dumbing down of Scratch or Logo. Visual block programming. Turtle Graphics. Sprites. Lexical scoping. Lambda. Closures. Call/cc. Plus JavaScript integration and web stuff. With extensions for networking, AI, machine learning, speech synthesis and recognition, graph theory, robotics, Lego, Arduino, 3d graphics, 3d design, 3d fabrication, and 3d printing, embroidery, etc. ;)
History of Logo. Proc. ACM Program. Lang., Vol. 4, No. HOPL, Article 79. Publication date: June 2020.
6.2 Brian Harvey’s Personal Narrative on Snap!: Scheme Disguised as Scratch (pp. 49-50)
In 2009, the University of California, Berkeley, was one of several universities developing a new
kind of introductory computer science course, meant for non-CS majors, to include aspects of
the social implications of computing along with the programming content. Scratch wasn’t quite
expressive enough to support such a course (it lacked the ability to write recursive functions), so
Prof. Daniel Garcia and I thought "What’s the smallest change we could make to Scratch to make it
usable in our course?" After 20 years teaching Structure and Interpretation of Computer Programs
[Abelson et al. 1984], the best computer science text ever written, I knew that the answer to "what’s
the smallest change" is generally "add lambda." I joined forces with German programmer Jens
Mönig, who had developed BYOB (Build Your Own Blocks), an extension to Scratch with custom
(user-defined) blocks, including reporters and predicates. At that time we were hoping to convince
the Scratch Team to adopt our ideas, so we took "smallest change" very seriously. BYOB 3.0 [Harvey
and Mönig 2010], with first class procedures and first class lists, added only eight blocks to Scratch’s
palette. (The code is almost all Jens’s. My contribution was part of the user interface design, plus
teaching Jens about lambda.) Version 3.1 added first class sprites with Object Logo-style inheritance.
The Berkeley course, The Beauty and Joy of Computing (BJC) [Garcia et al. 2012], is also used by
hundreds of high schools, especially since the College Board endorsed it as a curriculum for their
new AP CS Principles exam. Unfortunately, some teachers have no sense of humor, and so BYOB
version 4.0, a complete rewrite in JavaScript, was renamed Snap! [Harvey 2019]. [18]
Since Scratch seemed to be positioned as the successor to Logo, it was a goal for Snap! to restore
the features from Logo that are missing in Scratch. The most important missing feature, the ability
to define functions (and therefore to use recursive functions), is at the core of the new language.
(Scratch introduced user-definable command blocks in version 2.0, but still doesn’t support user defined reporters.) Scratch had also replaced the structured text (word and sentence) functions with
a flat text string data type. We wanted to be backward compatible with Scratch, so we implemented
words and sentences as a library, defining first, last, butfirst, and so on. (Since block languages
allow multi-word procedure names, and you don’t have to type the long name in order to use the
procedure, the library names are, e.g., all but first letter of.)
Lists are first class and can be arbitrarily deep in sublists. The usual higher order functions
on lists are provided; the graphical representation of lambda is built into the blocks representing
higher order functions, and so beginning users can use higher order functions in simple cases
without thinking hard about function-as-data at all, but the full power of lambda is available to
more advanced programmers. It took us three tries to get the lambda design right, but we’re very
proud of its pedagogic benefits.
Another of our goals for Snap! is to be a complete version of Scheme; it was largely as a way
of planting that flag that we added call with current continuation, not taught in BJC (nor
even in SICP) but used to implement tools such as catch and throw as library procedures written
in Snap! itself. As of this writing, macros are only half-implemented; users can define procedures
whose inputs are unevaluated (more precisely, thunked, since procedures are first class), but cannot
yet inject code into the caller’s environment.
Snap! is lexically scoped, not least to allow the use of closures as objects, but a planned extension
is "hybrid scope": variable names follow lexical scope, but instead of giving an error message when
no binding is found in the lexical environment, the evaluator will instead look in the dynamic
environment. So name capture is impossible, since the global environment is examined before the
dynamic environment. (Only if a mistyped name matches another name can the user get the wrong
variable rather than an error message. But mistyping can’t really happen in a block language.) This,
too, is an effort to be a Logo as well as a Scheme.
Since Snap! is free software (AGPL), it has served as the starting point for at least a dozen significant extensions, including BeetleBlocks [Koschitz and Rosenbaum 2012; Rosenbaum et al. 2011]
for 3-D graphics and 3-D printing; TurtleStitch [Mayr-Stalder and Aschauer 2016] for controlling
sewing machines to do embroidery; Edgy [Bird et al. 2013] for studying graph theory; NetsBlox
[Ledeczi and Broll 2016] for access to online data APIs and collaborative editing of projects; and
others. The ability to write new Snap! blocks in Javascript, from the Snap! editor, has allowed
many other user-level extension libraries, including support for robots and other hardware. Snap!
features such as first class procedures help authors develop these extensions, even if the users of
an extension don’t see that.
[18] For non-Anglophones, "BYOB" is used in party invitations as an abbreviation for "bring your own booze."
Agreed. My kids learned MicroWorlds Logo in elementary school from LCSI (Logo Computer Systems Inc). They definitely enjoyed the experience and it served a good preparation for learning other languages as they got older.
For those who don't know, all the wonderfulness of Logo is there because Logo is a Lisp dialect. Like they say in the ads, "If you like Logo, try Lisp!"
PS: Logo changed my life and made me want to be a programmer. PPS: We currently build back end tools with Lisp.
The submitted title was "A virtual machine and Pascal compiler in Berkeley LOGO" but that was a little misleading so we changed it to the book+chapter title.
