Lojic Technologies Blog

Learning Logo - Part 3

June 28, 2009 in programming | Add a comment

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

Tags: logo

Learning Logo - Part 2

May 6, 2009 in programming | Add a comment

Table of Contents

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?

Tags: logo

Programming in Standard ML - Part 2

May 2, 2009 in programming | Add a comment

Chapter 4 - Functions

Lambda expressions are written as:

fn var : typ => exp

For example:

fn x : real => Math.sqrt (Math.sqrt x)
(fn x : real => Math.sqrt (Math.sqrt x)) (16.0)
val fourthroot : real -> real =
  fn x : real => Math.sqrt (Math.sqrt x)
fourthroot 16.0

ML provides a special syntax for function bindings that’s more concise:

fun fourthroot (x:real):real = Math.sqrt (Math.sqrt x)

Local val bindings may shadow parameters and other val bindings. For example, in the following, the last occurrence of x refers to the parameter of h, but the preceding two occurrences of x refer to the local binding with a value of 2.0:

fun h(x:real):real =
  let val x:real = 2.0 in x+x end * x

Chapter 5 - Products and Records

The n-tuple is the simplest form of aggregate data structure. They are of the form:
(val₁, … ,val_n)
An n-tuple is a value of a product type of the form:
typ₁* … *typ_n
For example:

val pair : int * int = (2, 3)
val triple : int * real * string = (2, 2.0, "2")
val pair_of_pairs : (int * int) * (real * real) = ((2,3),(2.0,3.0))

A 0-tuple, also known as a null tuple, is the empty sequence of values, ( ). It is a value of type unit. 1-tuples are absent from the language.

Tuple Patterns

We can use pattern matching to extract portions of an n-tuple. For example, in the code snippet below, r will be equal to 3.14. Underscores indicate “don’t care” positions:

val foo : (int * string) * (real * char) = ((7,"hello"),(3.14,#"z"))
val ((_, _), (r:real, _)) = foo

We can give names to the first and second components of the pair - using the REPL:

- val (is:int*string,rc:real*char) = foo;
val is = (7,"hello") : int * string
val rc = (3.14,#"z") : real * char

A pattern is one of three forms:

A variable pattern of the form var : typ
A tuple pattern of the form (pat₁, …, pat_n), where each pat_i is a pattern. This includes as a special case the null-tuple pattern, ()
A wildcard pattern of the form _

Record Types

Tuples can become more difficult to use as the number of elements increases. Record types allow labeling each component. A record type has the form:
{ lab₁:typ₁, …, lab_n:typ_n}
A record value has the form:
{ lab₁=val₁, …, lab_n=val_n}
A record pattern has the form:
{ lab₁=pat₁, …, lab_n=pat_n}

For example, the record type hyperlink is defined as follows:

type hyperlink =
  { protocol : string,
    address  : string,
    display  : string }

The following record binding defines a variable of type hyperlink:

val mailto : hyperlink =
  { protocol = "mailto",
    address = "foo@bar.com",
    display = "Brian Adkins" }

The following record binding:

val { protocol=prot, display=disp, address=addr } = mailto

decomposes into the three variable bindings:

val prot = "mailto"
val addr = "foo@bar.com"
val disp = "Brian Adkins"

We can use wildcard to extract selected fields:

val {protocol=prot, address=_, display=_ } = mailto

However, this isn’t very helpful with many fields, so we can use ellipsis patterns:

val {protocol=prot, ... } = mailto

ML provides an abbreviated form of record pattern {lab₁,…lab_n} which stands for { lab₁=var₁, …, lab_n=var_n} where the variables have the same name as the corresponding labels. For example, the following:

val { protocol, address, display } = mailto

decomposes into these bindings:

val protocol = "mailto"
val address = "foo@bar.com"
val display = "Brian Adkins"

Multiple Arguments and Multiple Results

fun dist (x:real, y:real):real = sqrt (x*x + y*y)

Keyword parameters are supported through record patterns:

fun dist’ {x=x:real, y=y:real} = sqrt (x*x + y*y)

Invoked as follows:

dist' {x=2.0,y=3.0}

Functions with multiple results may be thought of as functions yield tuples (or records).

fun dist2 (x:real, y:real):real*real
  = (sqrt (x*x+y*y), abs(x-y))

Sharp notation allows us to conveniently access the Nth item in a tuple.

- val foo = (3,7,5,2);
val foo = (3,7,5,2) : int * int * int * int
- #3 foo;
val it = 5 : int

A similar notation is used for record field selection:

 - val foo = { name = "Brian", phone = "555-1212" };
val foo = {name="Brian",phone="555-1212"} : {name:string, phone:string}
- #name foo;
val it = "Brian" : string

However, Harper states, “Use of the sharp notation is strongly discouraged!“

Tags: sml

Programming in Standard ML - Part 1

May 2, 2009 in programming | Add a comment

The posts in this series will be notes & highlights from working through “Programming in Standard ML” by Robert Harper. See Getting Started with Standard ML for a link to the PDF. I may not always use quotes in this series, but it should be assumed that any factual information about Standard ML that I write in this series has been obtained from the PDF above.

Overview

Attributes of Standard ML:

Type-safe programming language
Statically typed
Extensible type system
Polymorphic type inference
Automatic storage management
Encourages functional (effect-free) programming
Allows imperative (effect-ful) programming where appropriate
Pattern matching
Extensible exception mechanism for handling error conditions
Expressive and flexible module system
Portable due to its precise definition
Portable standard basis library

Chapter 1 - Programming in Standard ML

This chapter provides a brief overview of the language by considering an implementation of a regular expression package. It was slightly more familiar to me because of my brief studies of Haskell; otherwise, I think it would’ve appeared very foreign. I prefer more of a bottom up approach as much as possible instead of looking at language features that haven’t been described.

Currying

I do think that currying & partial application are cool features. Consider the following function declaration:

val match : RegExp.regexp -> string -> bool

Coming from a non-currying background, I would describe match as a function that accepts a regular expression and a string, and returns a boolean value indicating whether the string matches the regular expression, but Robert describes it this way:

It contains a function match that, when given a regular expression, returns a function that determines whether or not a given string matches that expression.

This was one of the features that made a strong impression on me when I first started looking at functional programming languages.

Chapter 2 - Types, Values, and Effects

Computation in ML is of a somewhat different nature. The emphasis in ML is on computation by evaluation of expressions, rather than execution of commands.

An expressions has three characteristics:

It may or may not have a type
It may or may not have a value
It may or may not create an effect

Effects will be ignored until chapter 13, so until then, it’s assumed that all expressions are effect-free, or pure. A type is defined by specifying three things:

a name for the type,
the values of the type, and
the operations that may be performed on values of the type

Notes:

Negative numbers, as literals, are indicated with a tilde instead of a hypen e.g. ~7
div is used for integers, / for reals

A typing assertion has the form: exp : typ For example: 3 : int 4 div 3 : int ML does not perform any implicit conversions between types. Use real(3) + 4.3, or 3 + round(4.3) Conditional expression (exp1 and exp2 must have the same type): if exp then exp1 else exp2 if not exp then exp1 else exp2

Chapter 3 - Declarations

Once a variable is bound to a value, it is bound to it for life; there is no possibility of changing the binding of a variable once it has been bound. Examples of type bindings:

type float = real
type count = int and average = real

Examples of value bindings:

val m : int = 3+2
val pi : real = 3.14 and e : real = 2.17

One thing to keep in mind is that binding is not assignment. The binding of a variable never changes; once bound to a value, it is always bound to that value (within the scope of the binding). However, we may shadow a binding by introducing a second binding for a variable within the scope of the ﬁrst binding.

Limiting scope with let expressions:

let
  val m : int = 3
  val n : int = m*m
in
  m*n
end

The following expression evaluates to 54 because the binding of m is temporarily overridden during the evaluation of the let expression, then restored upon completion of this evaluation:

val m : int = 2
val r : int =
    let
        val m : int = 3
        val n : int = m*m
    in
        m*n
    end * m

Tags: sml

Getting Started with Standard ML

May 2, 2009 in books, programming | 1 comment

One of the two parallel tracks in my 2009 Programming Language Plan begins with the Standard ML programming language, so it’s time to get started.

Standard ML Resources

Compilers

Standard ML of New Jersey is highly recommended and comes with a REPL.
Moscow ML
MLKit
PolyML
MLton is a Standard ML compiler with excellent performance. However, as far as I know, it doesn’t have a REPL, which makes it less than ideal for learning.

Books

Since I was unfamiliar with the Standard ML programming language, I was surprised to find there are a number of good books about the language. Following are just some of them:

Elements of ML Programming

ML for the Working Programmer

Purely Functional Data Structures

The Definition of Standard ML

The Standard ML Basis Library

Introduction to Programming using SML

Concurrent Programming in ML

Other Educational Materials

Programming in Standard ML - excellent online book by Robert Harper of Carnegie Mellon University. Since I don’t know if Standard ML will simply be a stepping stone to Haskell (which in turn may not be a primary language for me) or a language I invest a lot of time in, I’m going to restrict myself from my normal method of purchasing a book or two when learning a new language. Instead, I’ll be going through Harper’s online book initially.

Hello World

There are a number of great compilers for Standard ML (listed above), but I only need one to get started, so I chose Standard ML of New Jersey despite the funky name. It’s a popular version, and it has a REPL, so it’s good enough for me for now.

I develop software on Mac OSX and deploy on Ubuntu Linux. On my Ubuntu server, installing SML/NJ was as simple as:

sudo apt-get install smlnj

On Mac OSX, there are a couple of options listed on this page. I could use a pre-built system or the generic Unix install, so naturally I chose the generic Unix install which installed easily according to the simple directions.

# Download config.tgz
tar xzf config.tgz
config/install.sh

# Wait for install to complete

~/software/smlnj$ rlwrap bin/sml
Standard ML of New Jersey v110.69 [built: Sat May  2 12:04:08 2009]
- print "hello, world\n";
hello, world
val it = () : unit
-

Great, looks like everything is working fine. Note, I use the rlwrap utility to provide a nicer REPL experience, but it’s not required.

I’ll continue with a series of posts with notes from working through “Programming in Standard ML”.

Tags: book, sml

2009 Programming Language Plan

April 27, 2009 in programming | 1 comment

Background

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:

ML Family	Lisp Family
Standard ML	Logo
Haskell	Scheme
	Common Lisp
	Clojure

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.

Tags: clojure, common_lisp, haskell, lisp, logo, ruby, scheme, sml

Programming Language Popularity

April 21, 2009 in programming | 7 comments

Despite the numerous ways in existence to quantify programming language popularity, I thought I’d throw yet another one into the mix. I made a number of Google searches of the forms below and averaged the results:

"implemented in <language>"
"written in <language>"

I’m very curious to see how these stats change over time, so I’ve added a calendar item to recompute them in six months. Leave a comment if you’d like to add a programming language to the list, and I’ll update this article and it will be included in the recomputation six months from now.

Language	# Results
C	1,905,500
Java	850,000
C++	699,000
PHP	680,000
Python	396,000
Perl	365,500
C#	349,700
Lisp Family¹	176,507
JavaScript	102,700
Ruby	99,650
Scheme	86,450
Lisp	61,900
Tcl	44,800
ML Family²	29,062
Haskell	22,550
Erlang	22,285
OCaml	22,000
Common Lisp	20,600
Prolog	17,750
Lua	13,065
Smalltalk	9,105
Arc	6,775
Forth	6,465
(S)ML³	5,173
Scala	3,570
Caml	1,889
Io	1,760
Clojure	782

¹ combines Lisp, Scheme, Common Lisp, Arc & Clojure
² combines OCaml, (S)ML, Caml
³ summed separate searches for sml and ml
Update 4/23/09 added C#, Tcl per comment requests.

Tags: arc, clojure, common_lisp, erlang, forth, haskell, io, java, javascript, lisp, lua, ocaml, perl, php, python, ruby, scala, scheme, smalltalk, sml, tcl

Use Ruby to parse NMEA sentences from your GPS

April 8, 2009 in programming, technology | Add a comment

I recently obtained a mobile broadband device that has a built in GPS receiver and can emit NMEA sentences. My old Garmin portable GPS can emit NMEA also, but it’s a pain to hookup to the laptop. Combining a GPS unit in a mobile broadband device is a great idea.

Update: it appears that the accuracy radius of the wireless card is quite a bit larger than my old Garmin unit. The Garmin is usually between 15 and 30 feet, but the Sierra Wireless 598U ranges from 100 to 1,000 feet or more.

After installing the ruby-serialport gem, I was able to write a simple Ruby program to read GPS information from the device and update a remote file on my web server to allow real time location tracking.

Add a simple server side script to read the file and update an iframed Google Map and you’re all set.

The code is also in the Ruby section of my sample code repository on Github.

sudo gem install ruby-serialport

#!/usr/local/bin/ruby
# Author: Brian Adkins
# Date:   2009/04/08
# Copyright 2009 Brian Adkins - All Rights Reserved
#
# Ruby program to retrieve and parse GPS information (via NMEA sentences)
# from a Sprint Sierra Wireless 598U device.
#
# ruby gps-nmea.rb                # prints latititude/longitude info
# ruby gps-nmea.rb update-remote  # scp a file of location info to a remote server
#
# This program depends on the ruby-serialport gem:
# sudo gem install ruby-serialport
#
# From: http://www.gpsinformation.org/dale/nmea.htm#GGA
#  $GPGGA,123519,4807.038,N,01131.000,E,1,08,0.9,545.4,M,46.9,M,,*47
# Where:
#      GGA          Global Positioning System Fix Data
#      123519       Fix taken at 12:35:19 UTC
#      4807.038,N   Latitude 48 deg 07.038' N
#      01131.000,E  Longitude 11 deg 31.000' E
#      1            Fix quality: 0 = invalid
#                                1 = GPS fix (SPS)
#                                2 = DGPS fix
#                                3 = PPS fix
#              4 = Real Time Kinematic
#              5 = Float RTK
#                                6 = estimated (dead reckoning) (2.3 feature)
#              7 = Manual input mode
#              8 = Simulation mode
#      08           Number of satellites being tracked
#      0.9          Horizontal dilution of position
#      545.4,M      Altitude, Meters, above mean sea level
#      46.9,M       Height of geoid (mean sea level) above WGS84
#                       ellipsoid
#      (empty field) time in seconds since last DGPS update
#      (empty field) DGPS station ID number
#      *47          the checksum data, always begins with *

require 'rubygems'
require 'serialport'

# Emacs macro to reset user modified values (highlight, then: M-x eval-region )
# ((lambda (&optional arg) "Keyboard macro." (interactive "p") (kmacro-exec-ring-item (quote ("USERNAME
\"
\372\"HOSTNAME
\"
\372\"REMOTE_DIR
\"
\372\"" 0 "%d")) arg)))

# --- MODIFY THESE -- #
USERNAME   = ""  # Username for remote host
HOSTNAME   = ""  # Remote host name e.g. foo.com
REMOTE_DIR = ""  # Remote directory e.g. /var/www/bar
# --- MODIFY THESE -- #

port_str  = '/dev/cu.sierra05'
baud_rate = 9600
data_bits = 8
stop_bits = 1
parity    = SerialPort::NONE

sp = SerialPort.new(port_str, baud_rate, data_bits, stop_bits, parity)

# lat is of the form 4807.038 where the first 2 digits are degrees and
#   the remainder is minutes.
# dir is either 'N' or 'S'
def convert_lat lat, dir
  degrees = lat[0,2].to_f + (lat[2,lat.length-2].to_f / 60.0)
  dir == 'N' ? degrees : -degrees
end

# lon is of the form 01131.000 where the first 3 digits are degrees and
#   the remainder is minutes.
# dir is either 'E', or 'W'
def convert_lon lon, dir
  degrees = lon[0,3].to_f + (lon[3,lon.length-2].to_f / 60.0)
  dir == 'E' ? degrees : -degrees
end

TEMP_PATH = '/tmp'
TEMP_FILE = 'location.txt'

def update_remote_info lat, lon
  File.open("#{TEMP_PATH}/#{TEMP_FILE}", 'w') do |tf|
    tf.puts Time.now.to_s
    tf.puts "#{lat},#{lon}"
  end
  puts 'Updating remote location info'
  `scp #{TEMP_PATH}/#{TEMP_FILE} #{USERNAME}@#{HOSTNAME}:#{REMOTE_DIR}/#{TEMP_FILE}`
  File.delete("#{TEMP_PATH}/#{TEMP_FILE}")
end

# 99 requests should be sufficient to find a $GPGGA sentence
99.times do
  if (str = sp.gets) =~ /^\$GPGGA/
    fix = str.split(',')
    if fix[6] == '1'
      lat = convert_lat(fix[2], fix[3])
      lon = convert_lon(fix[4], fix[5])
      if ARGV[0] == 'update-remote'
        update_remote_info(lat,lon)
      elsif
        puts "#{lat}, #{lon}"
      end
      exit 0
    end
  end
end

puts "Invalid data - GPS coordinates not found"

Tags: gadgets, gps, programming, ruby

Retrieve Sunrise, Sunset & Twilight Info in Ruby

March 11, 2009 in internet, programming, science, technology | 1 comment

Sunrise, Sunset & Twilight

I was curious about the exact time of sunrise & sunset at my location, so I found this US Naval Observatory site. In the process, I learned a more precise definition of twilight. I wanted to be able to automate the process of retrieving the information, so my first attempt was to simply put the query parameters used in the form in the URL as an HTTP GET request, but the server wouldn’t accept that, so I needed to issue an HTTP POST request.

Ruby Code

Ruby is a great language for this sort of task, so I put together the following simple program:

require 'net/http'

YOUR_ID    = ''    # A unique ID per comment above
YOUR_CITY  = ''    # The name of your city
YOUR_STATE = ''    # Two letter state abbreviation

now   = Time.now
month = now.month
day   = now.day + 1 # Tomorrow
year  = now.year

Net::HTTP.start('aa.usno.navy.mil') do |query|
  response = query.post('/cgi-bin/aa_pap.pl',
    "FFX=1&amp;amp;amp;ID=#{YOUR_ID}&amp;amp;amp;xxy=#{year}&amp;amp;amp;xxm=#{month}&amp;amp;amp;xxd=#{day}&amp;amp;amp;st=#{YOUR_STATE}&amp;amp;amp;place=#{YOUR_CITY}&amp;amp;amp;ZZZ=END")
  if response.body =~ /Begin civil twilight[^0-9]*(\d+:\d{2} [ap].m.).*Sunrise[^0-9]*(\d+:\d{2} [ap].m.).*Sunset[^0-9]*(\d+:\d{2} [ap].m.).*End civil twilight[^0-9]*(\d+:\d{2} [ap].m.)/m
    puts "#{month}/#{day}/#{year}"
    puts "Begin Twilight: #{$1}"
    puts "Sunrise       : #{$2}"
    puts "Sunset        : #{$3}"
    puts "End Twilight  : #{$4}"
  end
end

You just need to edit the three constants that begin with YOUR_. The id used on the Navy web form is ‘AA’, but they have a comment in the HTML that requests you use a unique id of your own up to 8 characters to help them with tracking. You can find a more complete version of the code in my github profile.

Emacs Goodness

After writing the above Ruby script, I made it executable, ‘chmod +x sunrise.rb’, and placed it in my path so I could write a simple Emacs function to invoke it.

(defun bja-sunrise ()
  "Display sunrise, sunset &amp; twilight information."
  (interactive)
  (shell-command "sunrise.rb"))

Imagine my surprise when I invoked the Emacs apropos help ‘C-h a’ to see my newly defined function and discovered that Emacs, naturally, already has several commands to display sunrise/sunset information!

calendar-mouse-sunrise/sunset: Show sunrise/sunset times for mouse-selected date.
calendar-sunrise-sunset: Local time of sunrise and sunset for date under cursor.
sunrise-sunset: Local time of sunrise and sunset for today. Accurate to a few seconds.

It doesn’t, however, display twilight information, so my simple function still has a purpose in life. Emacs is awesome :)

Tags: astronomy, emacs, github, http, programming, ruby, usno

Tarski Wordpress Theme

March 10, 2009 in communication, web design | Add a comment

Tarski Theme

I’ve switched to the Tarski Wordpress theme for both this and my personal blog. Thanks to Jordan for the tip on the theme and for helping me to get up to speed quickly. I think Tarski is a nice theme with a reasonable set of configurable options. Being able to easily specify a custom style sheet is a big plus. With a couple of lines of css, I was able to widen my page enough to fit most of my code snippets.

After the theme switch, I took some time to reduce my category list considerably and use tags in place of the deleted categories. I also added category counts to provide some useful feedback.

Comments Plugin

Thanks to a comment on Jordan’s blog, I grabbed a simple plugin to change the text that’s displayed when there are no comments from “No comments” to “Add a comment”. The former could imply that “no comments are allowed” vs. “no comments exist yet”.

Just drop the following code in wp-content/plugins/change_no_comments.php and activate the plugin in the admin UI:

<?php
  /*
  Plugin Name: Change Comment Text
  Plugin URI:  http://tarskitheme.com/
  Description: Change comment text to something else.
  Author:      Benedict Eastaugh
  Version:     1.0
  Author URI:  http://extralogical.net/
  */

  function change_no_comments_text($text, $number) {
    if (0 == $number) { $text = 'Add a comment'; }
    return $text;
  }
  add_filter('comments_number', 'change_no_comments_text', 10, 2);
?>

Wordpress as a CMS

Next I’ll be testing the boundaries of Wordpress as a general purpose CMS. My initial assessment is that even though I much prefer Ruby over PHP as a programming language, the maturity, ease of use, feature richness, availability of documentation & developers, etc. of Wordpress outweighs the disadvantages of the implementation language for a large set of clients.

Tags: blog, cms, css, plugin, wordpress

« Older entries

Chapter Three - Variables

Key Ideas

Questions

Background

Chapter One - Exploration

Key Ideas

Questions

Chapter Two - Procedures

Key Ideas

Questions

Chapter 4 - Functions

Chapter 5 - Products and Records

Tuple Patterns

Record Types

Multiple Arguments and Multiple Results

Overview

Chapter 1 - Programming in Standard ML

Currying

Chapter 2 - Types, Values, and Effects

Chapter 3 - Declarations

Standard ML Resources

Compilers

Books

Other Educational Materials

Hello World

Background

Motivation

The Problem

The Process

Efficiency

Concurrency

Joy

Fundamental Nature

Community

Education

Productivity

Licensing

The Final Candidates

The Lisp Family

The ML Family

The Plan

Sunrise, Sunset & Twilight

Ruby Code

Emacs Goodness

Tarski Theme

Comments Plugin

Wordpress as a CMS

Pages

Categories

Tags

Links

Archives

What I'm currently reading