Chapter Four – Predicates

Key Ideas

A predicate is an operation whose output is always either the word true or the word false.
For example:

? print listp [ hello ]
true
? print listp "hello
false
? print listp [ hello ]
true
? print listp [ ]
true
? print wordp "hello
true

By convention, predicates often end in ‘p’ or ‘?’. Here’s an example of defining your own predicate using a built-in predicate:

to vowel? :letter
  output memberp :letter [a e i o u]
end

? print vowel? "i
true
? print vowel? "y
false

if is a command with two inputs. The first input must be either the word true or the word false. The second input must be a list containing Logo instructions. If the first input is true, the instructions are evaluated.

ifelse is a procedure that requires three inputs. The first input must be either the word true or the word false. The second and third inputs must be lists of Logo instructions. If the first input is true, the list in the second input is evaluated; otherwise, the list in the third input is evaluated. ifelse is unusual in that it can be used as a command or operation.

test is a command that takes one input that is either true or false. test stores its input in special variable that is local to the procedure from which test is invoked. iftrue (abbreviated ift) is a command with one input – a list of Logo instructions which are evaluated if the most recent test command stored true. iffalse (abbreviated iff) is similar except that the list of instructions are evaluated if the recent test was false.

and is a predicate with two inputs each of which must be true or false. The ouput is true if both inputs are true; otherwise, it is false.

or is a similar predicate whose output is true if either input is true.

not is a predicate with one input (true or false) whose output is the opposite of the input.

When ifelse is used as an operation, the output is the result of evaluating the list of instructions in either the second or third inputs depending on whether the first input was true or false respectively. For example:

? print sentence "It's ifelse 2=3 ["correct] ["incorrect]
It's incorrect

to abs :number
  output ifelse :number < 0 [-:number] [:number]
end

? print abs -7
7
? print abs 7
7

stop is a command that takes no inputs that finishes the evaluation of the procedure in which it is used. An output command also finishes the evaluation of the procedure in which it occurs. If you're writing an operation, which should have an output, you use output; if you're writing a command, which doesn't have an output, you use stop.

repeat is a command with two inputs. The first input is a non-negative whole number. The second input is a list of Logo instructions which will be evaluated the number of times given as the first input.

Questions

1) What type of operation always outputs either the word true or the word
   false?

2) Do names of predicates have to end in the letter p? Is it a good idea
   to name your predicates with names ending in the letter p? What would
   be another good way to name a predicate?

3) List eleven primitive predicates that are named in this chapter:

4) What is another way to say the same thing as the following?
   equalp "hello last [goodbye hello]

5) Fill in the blank so the command prints true:
   print memberp ______ [barnes noble]

6) Fill in the blank so the command prints true:
   print memberp _____ "chitty

7) Create a predicate, even?, that returns true if the input is even.

8) Write a procedure that will print the specified output when given
   the specified input:
   input: Brian
   output: [Hello Brian]

   input: [Brian Adkins]
   output: [Hello Mr. Adkins]

   input: [Brian Xavier Adkins]
   output: [Xavier is a nice middle name.]

9) Write integerp, as described on p. 66

10) Write the procedure converse that's described on the bottom of p. 67.

11) Read the section entitled "About Those Brackets" on the top of p. 69 again to
    make sure you understand it.

12) Which primitive predicates takes only one input?

13) Use the operation form of ifelse to output the input word backwards if it has
    an odd number of characters or output it normally if it has an even number of
    characters.

    to evenword? :value
      output equal? 0 (remainder count :value 2)
    end

    to condreverse :value
      output ifelse ______________________________________________
    end

    print condreverse "hello   -> olleh
    print condreverse "hi      -> hi
    print condreverse "daddy   -> yddad

14) How are output and stop similar? How are they different?

15) Write a predicate, palindrome?, that outputs true if a word is a
    palindrome. A word is a palindrome if it is the same forward and backward.

    print palindrome? "hello  -> false
    print palindrome? "mom    -> true
    print palindrome? "wow    -> true

16) Write a procedure that uses the palindrome? predicate you wrote in #15 to
    accept a list and output a list containing only the words that are
    palindromes.

    print palindromes [hello mom daddy wow doogood] -> mom wow doogood

After bumping into a number of local programmers who expressed an interest in functional programming, I thought it might be a good time to start a local group that focused on functional programming languages, so I did a couple days ago.

TriFunc.org is a group for programmers who are interested in functional programming languages and live near the Research Triangle area of North Carolina.

If you live in the area and have an interest in functional programming languages, feel free to dive in and start participating in the Google Group discussions. Once we reach a critical mass, I expect we’ll produce a meeting schedule, etc., but that will depend on where the group wants to take this.

Part 3 was written with the help of my daughter.

Chapter Three – Variables

Key Ideas

To have a procedure accept input parameters, provide the names of the input parameters preceded by a colon. The colon provides a distinction between the procedure name and input parameters. Some versions of Logo don’t require the colon.

to greet :person

Thing is an operation that takes an input which is the name of a container and outputs the contents of the container.

? to greet :person
> print sentence "Hello, thing "person
> end
greet defined
? greet "Brian
Hello, Brian

An abbreviation for thing “person is to simply use a colon.

:person

Sometimes you can even leave the colon off, but you shouldn’t depend on that.

Readlist is an operation that waits for you to type a line, then outputs what you type.

output is a command that has the effect of making its input available as the output of the procedure it’s within.

Logo uses dynamic scope for its variables; however, it’s good style to minimize referencing variables in calling procedures.

make is a command that accepts two inputs. The first input is a word that is the name of a variable; the second input is a value to assign to the variable.

? make "name [Brian Adkins]
? print :name
Brian Adkins

The following two lines are equivalent:

make "new :old
make first [new old] thing last [new old]

If the first input to make refers to a non-existent variable, a new globabl variable is created. To create a variable local to the procedure, use the local command.

make can use computed names in addition to quoted names. For example, the increment procedure below:

? to increment :variable
> make :variable (thing :variable)+1
> end
increment defined
? make "foo 7
? increment "foo
? print :foo
8

A procedure is functional if it always gives the same output when invoked with the same input(s).

Questions

1) Work through all the examples in the chapter to make sure you
   understand them.

2) Every variable has a ____ and a _____.

3) Define "formal parameter" and "actual argument"

4) What is another way to say the following?
    thing "name

5) Take problem #8 from chapter 1 and solve it without using make to
   store a temporary variable. Do you like this solution better or
   worse than your solution in chapter 1?

6) A complete instruction begins with which of the following?
  operation
  command

7) Write the procedure you're asked to write on p. 46 to conjugate
   French verbs.

8) Consider the following command:

  to thang :thing
    print thing :thing
  end

   How would you invoke this procedure to get it print the following?

   thing

9) Write the procedure you're asked to on p. 49:

10) Write the helper procedure you're asked to write on p.54

11) What will the following print?

  make "foo 7
  make last [foo oof] sum thing first [foo oof] 7
  print oof

12) How do you prevent a global variable from being created when using
    make with a name that is not the name of an input?

13) What will the following print?
  make "a "b
  make "b "c
  make "c "d
  make "d 7
  print thing thing thing "a

Background

It’s been a while since I posted Learning Logo – Part One. I’ve resumed Logo lessons with my kids, so I thought I’d post the chapter questions I’ve created for each chapter to accompany Brian Harvey’s excellent texts (see link above for free PDF files for the textbooks).

Chapter One – Exploration

Key Ideas

Chapter one introduces Logo and some of the vocabulary. Simple procedures are written and you learn how to save and load files.

Questions

1) Write a program to print the following:
   Hello, world!

2) What version of Logo are you using?

3) How many times will hello be printed with the following program?
   repeat 2 [repeat 2 [repeat 2 [print "hello]]]

4) What is the word to clear the screen? What is its abbreviation?

5) Write a program to print your name 10 times.

6) What does the name Logo come from?

7) Name some Logo procedures.

8) How do you save the workspace to a file named my.logo?

9) How do you load a file named my.logo into the workspace?

Chapter Two – Procedures

Key Ideas

Everything in Logo is done with procedures. Initially, Logo knows about 200 procedures. These are called primitive procedures.

Using the output from one procedure as an input to another procedure is called composition of functions.

In Logo there are two kinds of procedures: commands and operations. An operation is a procedure that computes a value and outputs it. A command is a procedure that does not output a value, but instead has some effect such as printing something on the screen, moving a turtle, or making a sound.

To have Logo treat a word as itself instead of evaluating it, you must quote the word by typing a quotation mark (”) in front of it.

You can combine several words to form a list by using square brackets. For example, [Hello world]. The members of a list can also be lists. For example:

[ [North Carolina] Ohio [South Dakota] ]

The brackets in Logo serve two purposes – they delimit a list and they also quote the list so the members are not evaluated as procedures.

Logo provides several operations for taking data apart and putting data together. Words come apart into characters and lists come apart into whatever data are the members of the list. A sentence, which is a list of words, comes apart into words. For example:

? print first "Hello
H
? print first [How are you?]
How

Logo provides infix arithmetic as well as prefix arithmetic. For example:

print 2+3
vs.
print sum 2 3

Certain primitive procedures can be given extra inputs, or fewer inputs than usual, by using parentheses around the procedure name and all its inputs. For example:

? print sum 2 3 4
5
You don't say what to do with 4
? print (sum 2 3 4)
9
? show (list "one)
[one]
? show (list)
[ ]

Sum, product, word, list, sentence, and print can be used with any number of inputs.

Logo allows creating your own procedures. For example:

to hello
  print "Hello
end

Questions

1) What is the word that describes the special punctuation and organization of
   a programming language?

2) About how many procedures does Logo know without you teaching it any? What
   type of procedures are these (e.g. what is a word that describes them)?

3) What is the word that refers to a value that one procedure computes and
   hands on to another procedure?

4) Using the examples of tanks with inputs and outputs as described on p. 15,
   draw a picture of the following, then use the picture to determine what will
   be printed before trying it in Logo:

  print product sum 1 sum 2 3 sum 4 5

5) What are the two kinds of procedures in Logo? What is the difference between
   them?

6) Why doesn't the following code work?
  print Hello

7) Fill in the blanks, "In computer science, to _____ something means to
   prevent it from being ________."

8) What are four ingredients of a proper description of a procedure?

9) What will the following print?
  print first first [Hello world]

10) How many inputs does the sentence operation take?

11) What will each of the following instructions print? Think about why.
  print sentence [one two] [three four]
  print list [one two] [three four]
  print item 2 list [one two] [three four]
  print item 2 sentence [one two] [three four]

12) Use only the following procedures and data (you can use them more than
    once) to print Logo

  first butfirst butlast word print [I Love Pogo]

13) How would you write an instruction to print the sum of 1, 2 and 3?

14) What are three reasons parentheses are used in Logo instructions?

The 2008 Programming Language Plan didn’t go as well as I hoped, so I’m regrouping for another go at it. I did make progress learning some Logo and teaching it to my daughters, and I worked through seven chapters of “Programming in Haskell” which was very enjoyable, but I also spent way too much time trying to decide which language(s) to learn without actually learning them.

I have now decided which languages I want to learn this year, so I figured I’d post this blog entry. In some respects, things haven’t changed much from last years plan, but my decisions are much less tentative which is encouraging. I’m glad to switch from information gathering to actually learning a few languages.

Motivation

When I switched from C++ to Java in 1996 and noticed a large increase in productivity; however, it didn’t occur to me to consider whether switching from Java to another language might also give me a similar boost in productivity. The job demand for Java was high during the 10 years I used it, and I was getting paid for my time vs. what I produced, so the oversight wasn’t too costly.

When I switched from Java to Ruby in 2006 I experienced a comparable, if not greater, boost in productivity as I had with the switch from C++ to Java. This time I considered the effect of programming language choice on productivity more carefully and began to wonder about the optimal programming language for me. As a small business owner, my primary consideration is productivity, not popularity or the interchangeableness of programmers.

I don’t think a perfect programming language exists in general, but I think there is an optimal language for me given my particular circumstances, the problems I want to solve, the type of software I want to develop, my way of thinking, my aesthetic tastes, etc.

The Problem

There is a cost to research programming languages to determine the optimal one, and there is a cost to switch programming languages, so the benefit of a new programming language needs to exceed those costs.

Additionally, a significant catch-22 exists in that to truly determine if a language is optimal, one must reach a level of proficiency with the language. There isn’t enough time to learn all of the candidate languages, so some filtering mechanism must be used first to narrow the choices to a reasonably small set. This filtering mechanism is theoretical by nature, but I think the subtle practicalities of a language have a significant effect on productivity.

I have a long term perspective for this task, so I don’t mind investing time researching programming languages, and I also don’t mind if I need to develop/acquire supporting libraries before being ultimately more productive than I am currently with Ruby and Rails.

The Process

I briefly entertained the idea of going about this research in a more systematic, scientific way. That might be a reasonable approach, but due to the following:

• My laziness
• The high degree of subjectivity in programming language choice
• The lack of consensus among programming language researchers

I ended up with a fairly ad-hoc approach involving examining the following areas and trying to absorb enough information to formulate a plan:

Efficiency

Programming language efficiency is becoming increasingly important to me as Moore’s law loses steam, and power & cooling issues become more prominent.

On the one hand, Ruby is near the bottom of the pack with respect to efficiency, but the productivity has been outstanding, and at the volume of transactions I’ve needed to deliver thus far, performance hasn’t been a problem.

On the other hand, if programming languages exist (and I believe they do) that have similar or greater power than Ruby but are compiled instead of interpreted, that would be an advantage.

Benchmarks are notoriously controversial with respect to the degree in which they predict performance, but I don’t think they’re irrelevant. One popular benchmark site is: Programming Language Shootout. I also created some micro-benchmarks of my own to test performance.

One negative result of Ruby being inefficient is the disparity in performance of code written in Ruby vs. library code, or extensions, written in C. This creates counter-intuitive scenarios where a piece of code that appears less efficient is actually more efficient because of the use of built-in code implemented in C. I don’t like thinking in those terms; I would much prefer that user written code in the language is much closer to the efficiency of built-in library code.

Concurrency

With the flattening of CPU MHz and proliferation of CPU cores, I think concurrency may continue to grow in importance. Although I develop mainly server side web applications which can take advantage of multiple cores by virtue of having multiple independent processes, I would prefer to have better concurrency mechanisms in the language/libraries directly.

Joy

I think I first heard joy used, in the context of programming languages, in the Ruby community – probably from Matz himself. I have to agree that programming in Ruby has been more joyful than previous programming languages.

I’m not sure exactly why this is, but I expect it has something to do with the effectiveness and productivity of Ruby, but it may be helped by the incredibly friendly Ruby community.

Fundamental Nature

My preference is for a programming language to minimize arbitrariness and to maximize orthogonality. In other words, I would prefer the language to have a minimal set of core concepts/axioms/operators/etc. that are built upon systematically.

Community

Whether my optimal language is mainstream or not is irrelevant to me, so I don’t need the programming language community to be large (and in fact, being too large is a detriment), but I do think it should be active enough that there are people available to help answer questions, write libraries, maintain/improve compilers, debuggers etc.

To this end, I spent time on various usenet groups, IRC channels and blogs. Occasionally asking questions, but mostly observing the dialog and interaction among the community members.

Education

What educational materials are available?

I tend to prefer learning from books, so searching Amazon to see what books are available, how well they’re received, etc. was helpful. Although I prefer books typically, in the exploratory stages, it’s cheaper to go through online materials, so searching the web for free PDFs was useful. The existence of a few good texts is also an indication of the vitality of community.

Productivity

Ultimately, I’m after the most productive language for me; however, I think productivity is the factor that requires the most proficiency with a language to judge, so it was the most difficult factor to research prior to learning a language. I was limited to anecdotal stories, case studies, personal testimonies, etc.

Licensing

I prefer open source licensing because I think programming languages with proprietary licensing are more likely to die.

The Final Candidates

I began with Ruby as the point of reference irrespective of Rails and other libraries. Even though Rails is an important factor in my current productivity, since I’m taking a long term view, I didn’t want to exclude a fantastic language simply because it’s lacking something that Ruby was also lacking N years ago.

Due to the cost of researching, learning and switching to a new programming language, I only considered languages that had the potential of offering a significant improvement in one or more areas without losing too much in other areas.

The candidates I eventually selected fell into two groups. Both groups have strong functional capabilities, good efficiency, and long, successful track records. I believe that even the best programming language designers make serious mistakes which can only be identified with the hindsight of years of use. It’s possible that someone is about to release a brand new language that has the potential to be the most productive for me personally; however, I’m not willing to take the risk to learn it.

The Lisp Family

Lisp has a very long track record of success and adaptability. In fact, if I was forced to program in a single programming language from now on, I would probably choose a Lisp since I think it would have the greatest likelihood of being able to adapt.

The Lisp family has dynamic typing which I’ve grown to love with Ruby, but most also allow type declarations for efficiency. Lisp also appears to have a more fundamental nature than most languages. I’ve heard it said that Lisp was more discovered than invented.

I first became interested in Lisp when I learned that Ruby was influenced by it. My interest was reinforced by some of Paul Graham’s essays & books. I like the exploratory and dynamic nature of developing Lisp – this is mostly from reading comments of others, but I’ve tasted a small part of this when evaluating Lisp code in Emacs and having it be available immediately.

Logo is first on the list simply because it’s both a Lisp and a great language for teaching children how to program, so I can kill two birds with one stone.

Scheme is next because it’s a natural sequel to Logo and I still want to work through “The Structure and Interpretation of Computer Programs”. The fact that Paul Graham chose mzcheme to create his Arc language is a good “letter of recommendation”. Scheme feels the most fundamental, simple & clean thus far.

Common Lisp is after Scheme due to its eminent practicality and completeness. It has plenty of warts, but also plenty of power and functionality. It’s been called a great, big, ball of mud – but in a good way ;)

Lastly, is Clojure. It’s last in the Lisp family because I want to learn Scheme & Common Lisp first so I’ll be better equipped to judge Clojure. This will also allow more time for Clojure to mature. Clojure has a focus on functional programming & concurrency that is symbiotic with the Java platform. The latter provides a quick start and access to Java libraries, the JVM infrastructure, etc., but my preference would be to not be dependent on the JVM in the long run. I’ll withhold judgment until I’ve learned it and used it for a while.

The ML Family

I’m least familiar with the ML family and with functional programming in general. I’ve spent most of my career studying and using imperative, object-oriented programming languages.

I think the ML family is worth studying because:

• Functional programming may be beneficial with respect to concurrency.
• Prog. Lang. researchers seem to be enamored with ML family.
• There are enough anecdotal testimonies of productivity to warrant further study.

Standard ML is an important functional language that differs from Haskell in that it’s impure, i.e. it allows side effects, and it’s strict, i.e. not lazy. It shares Hindly-Milner static typing with Haskell. The community seems rather tiny, and I expect that if I go with a static typed language it will likely be Haskell, but I wanted to learn Standard ML first because of its historical importance and to be able to compare an impure/strict language with a pure/nonstrict language.

Haskell is probably the most different programming language from what I’m used to. This, in and of itself, has some advantages with respect to gaining new perspectives and ideas. In some ways, it’s a language that has taken things to extremes with respect to functional purity and laziness.

The community is very active. It offers a great compiler (GHC), software transactional memory, a decent base of libraries, etc.

At this early stage, I’m skeptical of static typing, functional purity and laziness, so becoming proficient in Haskell is a great opportunity to be able to determine how I feel about those.

The Plan

Rather than go through the candidates sequentially, I’m going to try and make progress on two tracks concurrently to allow me to compare concepts from both families:

I’m curious to find out how I feel about these languages after I’ve achieved some skill with them, but I think becoming proficient in the Lisp and ML families will be time well spent. At minimum, I’ll be better equipped to compare other languages.

More recently I’ve enjoyed learning new programming languages both for the joy of learning something new, and for an increase in productivity.

While it’s true that no programming language is a silver bullet, I’ve found that the choice of programming language can provide a dramatic increase in productivity – much more so than many have asserted. The benefit can be direct, by allowing the creation of a solution to a particular problem with less time and effort than it would take using another language, or it can be an indirect by providing new ways to think about a solution.

Do you think language affects how we think?

The Past

In 1982, I spotted a Radio Shack Color Computer in a store window and immediately applied for a Radio Shack credit card which had a credit limit ($500) sufficient to purchase the computer which had 4K of RAM (I later upgraded to 16K) and no external storage (unless you count the ability to hook up a cassette recorder). Contrast the 16K RAM of that early machine with my current 2,097,152K RAM :)

That was the beginning of a life long interest in programming.

In the language list below, bold indicates a more significant professional involvement, and the year indicates when I first learned the language. I’ve also likely forgotten a few:

1. 1982 – Radio Shack Extended Color BASIC
2. 1983 – 6809e Assembler
3. 1983 – Pascal
4. 1984 – HP 48SX RPL
5. 1984 – S/360 Assembler
6. 1985 – COBOL
7. 1985 – dBase III / Metafile
8. 1985 – C
9. 1985 – 8088/8086 Assembler
10. 1986 – C++
11. 1996 – Java
12. 1997 – Perl
13. 2002 – C#
14. 2004 – Python
15. 2005 – JavaScript
16. 2006 – Ruby
17. 2007 – PHP

The Present

Currently, I program primarily in Ruby, followed by JavaScript and the occasional PHP script. Ruby is the most productive programming language I’ve used thus far. The combination of power, pragmatism & pleasure in programming is hard to beat. If it also had performance, it would be a truly great language.

I’ve also begun learning Logo as I teach my daughter how to program. Logo is a great introduction to the Lisp family, so I hope to leverage it as I learn Scheme and Common Lisp later this year.

The Future

After completing the Logo course with my daughter, I plan on moving on to Scheme as I go through Structure and Interpretation of Computer Programs which some have called the greatest computer science text ever written.

After Scheme I plan on learning Common Lisp which has the potential to replace Ruby as my primary programming language.

Beyond Logo/Scheme/Common Lisp, the following languages are of interest:

• Haskell
• Erlang
• Lua
• ML
• OCaml

If you know of candidates for a future programming language, feel free to add it in a comment.

You may notice that Smalltalk is lacking from the lists above. Despite its prominence in programming language history, I currently don’t feel that Smalltalk is sufficiently better/different than Ruby to warrant an investment in learning it.

After focusing on object oriented for twenty years, I have more of an interest in the functional world of programming languages (and multiple dispatch is cool :) ).

Update: I was just over at Hacker News and saw something I’ve seen many times before. In a nutshell, some guy was stating that Paul Graham’s success with ViaWeb had little to do with his choice of programming language (Lisp) and more to do with him just being a good hacker. In other words, he could’ve written it in any language. I’m so glad Paul responded because his response confirms my thoughts on the matter:

What a weird situation. I keep trying to tell people Lisp is great, and they say, no, no, you guys were just really good programmers. But if I’m such a good programmer, why don’t they believe me?

Paul Graham has written a lot on Lisp and is one of the main factors in me becoming interested in Lisp (along with the fact that Ruby pulled a lot of good ideas from it), but the simple quote above communicates volumes IMO.

• Part Two
• Part Three
• Part Four

I decided last spring that it was a good time to begin teaching my eldest daughter how to program. She was eleven at the time and had demonstrated both interest and aptitude. So after researching various programming languages, I chose to use the Logo programming language – specifically, Berkeley Logo.

There are many good programming languages to choose from to teach children how to program depending on their abilities and interests, but I felt the benefits of Logo gave it the edge. It has much of the power of the Lisp family of languages but with a simpler syntax. The syntax is very uniform which saves children from having to learn too many inconsistent oddities of other languages (including my current favorite, Ruby). I had a preconceived idea that Logo was primarily about turtle graphics, so I was quite surprised when I dug a little deeper and found a very expressive language built on a solid foundation. Having said that, I think the availability of turtle graphics in Berkeley Logo is a big plus for allowing visual feedback for children.

In August, I wrote a blog post comparing a short function (from Brian Harvey’s home page) in Logo and several other languages. Several people added other versions in the comments. It may give you a glimpse of the conciseness and expressiveness of Logo.

In deciding on a programming language, I purposely ignored IDEs. In fact, I’ve discovered that more powerful languages are much less dependent on the availability of good IDEs. For example, when I switched from Java to Ruby, I didn’t miss Eclipse at all, and I’m much more productive with Ruby and a good text editor than I was with Eclipse and Java. On the other hand, I’ve heard some glowing testimonial from Smalltalk and Lisp IDE users, so I expect I’ll be experimenting with Lisp IDEs in the future.

Getting Started

Many thanks to Brian Harvey of UC Berkeley both for UCBLogo (along with other contributors) and for making excellent teaching materials freely available.

On Ubuntu Linux, simply install the ucblogo package. This will also install a PDF reference manual for Berkeley Logo which I recommend becoming familiar with.

You can also find links for other platforms on Brian Harvey’s home page.

Here are links to the free text books:
Computer Science Logo Style Volume 1: Symbolic Computing
Computer Science Logo Style Volume 2: Advanced Techniques
Computer Science Logo Style Volume 3: Beyond Programming

There is also a comp.lang.logo usenet group. You can access that via an nntp reader, or via Google below:
http://groups.google.com/group/comp.lang.logo/topics?hl=en

Methodology

My teaching methodology thus far has simply been to have my daughter read a chapter, and then complete a short assignment of questions and programming exercises that I’ve designed to ensure she’s mastered the important concepts in the chapter. I’ll spend some time with her explaining the solutions to problems she may have missed.

If there’s interest, I can provide the complete set of chapter assignments including questions & answers and programming problems & solutions once we’ve completed volume 1. Feel free to leave a comment, if you’d like a copy.

Some Quotes

Here are some quotes from the preface of “Computer Science Logo Style vol 1″ to whet your appetite :)

The truth is that Logo is one of the most powerful programming languages available for home computers.

In Logo there is only one syntax, the one that invokes a procedure.

More powerful languages are based on some particular mathematical model of computing and use that model in a consistent way. For example, APL is based on the idea of matrix manipulation; Proglog is based on predicate calculus, a form of mathematical logic. Logo, like Lisp, is based on the idea of composition of functions.

Conclusion

I highly recommend learning Logo whether you’re teaching your children to program or you simply want to learn another programming language. I’ve found both to be beneficial to my professional programming career. The Berkeley version of Logo is very powerful and has the following special features (from the intro to the UCBLogo reference manual):

• Source file compatible among Unix, Windows & Mac
• Random-access arrays
• Variable number of inputs to user-defined procedures
• Mutators for list structure
• First-class instruction and expression templates
• Macros

I’ve entitled this Part One because I intend to follow up with some more posts as we become more familiar with the language.

We’ve also been dabbling in some simple robotics projects. I would love to find a robotics controller, or kit, that allows programming in Logo – if anyone knows of such a thing, please let me know.

Happy programming :)

While perusing his site, I came across a tiny Logo program that demonstrates a little of its power. I was curious what it would look like in Ruby, so I ported it, then I had to see what it looked like in JavaScript.

The formatting is a little messed up due to Wordpress, but each of the three choices functions is 4 lines long.

If anyone wants to add other languages, that would be great!

See the sample page for example output.

Logo

to choices :menu [:sofar []]
  if emptyp :menu [print :sofar stop]
  foreach first :menu [(choices butfirst :menu
      sentence :sofar ?)]
end
choices [[small medium large]
  [vanilla [ultra chocolate] lychee [rum raisin] ginger]
  [cone cup]]


UPDATE 9/2/07: Got an even more concise solution from Brian Harvey:

to choices :menu
   foreach crossmap "sentence :menu "print
end

Ruby

def choices menu, sofar=[]
  if menu.empty?: puts sofar.join(' ')
  else menu[0].each {|item| choices(menu[1..-1],
    sofar + [item]) } end
end
choices [['small', 'medium', 'large'],
  ['vanilla', 'ultra chocolate', 'lychee', 'rum raisin', 'ginger'],
  ['cone', 'cup']]


JavaScript

function choices(menu, sofar) {
  if (emptyp(menu)) print(sofar);
  else foreach(menu[0],
   function (x) {
    choices(menu.slice(1), sofar.concat(x)); });
}
choices([['small', 'medium', 'large'],
  ['vanilla', 'ultra chocolate', 'lychee', 'rum raisin','ginger'],
  ['cone', 'cup']], []);


I had to create a few helpers for the JavaScript version:

function emptyp(a) {
  return a.length === 0;
}
function print(list) {
  foreach(list, function (x) { document.write(x + ' '); });
  document.write('<br />');
}
function foreach(arr, f) {
  for (var idx in arr) { f(arr[idx]); }
}


UPDATE: Use <pre> </pre> tags to allow easier formatting of code. Bummer, I just discovered that Wordpress strips the <pre> tags from normal users :( I’ll go ahead and wrap code with it as they come in, so if your comment looks bad at first, it’ll be cleaned up shortly.