## Monday, October 8, 2007

This time around, I’ve decided to toss the translations for Ruby, Factor, and Erlang into the same post instead of trying to juggle multiple posts and point them all at one another. So, without further ado …

## Section 1.1.6

Let’s take a look at section 1.1.6, the goal of this section is to look at conditional expressions through implementing an absolute value procedure. the book iterates through a couple of versions, trimming away fat. In each of my examples below, I’ve only shown the final product.

In Ruby, the code should look something like this:

``def abs(num)     if num < 0    num = -num  end  return numend``

In Factor it looks like this:

``: abs ( n -- n ) dup 0 < [ -1 * ] [ ] if ;``

And in Erlang it looks like this (I’ve left out the administrative bits from the top of the file):

``abs(A) ->    case ( A < 0) of    true -> -1 * A;    false -> A    end.``

## Exercise 1.3

Esercise 1.3 asks the reader to write a procedure that takes three numbers and returns the sum of the squares of the largest two of them. In each case below, I rely on the previously defined square and sum-of-squares (sum_of_squares) procedures.

Ruby was pretty easy:

``def sum_squares_of_larger(a, b, c)  sorted_nums = [a, b, c].sort.reverse  sum_of_squares(sorted_nums, sorted_nums)end``

Factor took me a while to figure out (mostly in trying to figure out how to build the array):

``: top-two ( x,y,z -- x,y ) 3array natural-sort reverse first2 ;: sum-squares-of-larger ( x,y,z -- x ) top-two sum-of-squares ;``

I’m least sure of my Erlang code. I couldn’t find a good function for sorting the array, so I borrowed the qsort function from Programming Erlang. In any case, here’s my cut at it:

``qsort([]) ->     [];qsort([Pivot|T]) ->    qsort([X || X <- T, X < Pivot])    ++ [Pivot] ++    qsort([X || X <- T, X >= Pivot]).last_two([H|T]) ->     T.sum_of_squares_of_list(L) ->    lists:sum([square(A) || A <- L]). sum_squares_of_larger(A, B, C) ->    sum_of_squares_of_list(last_two(qsort([A,B,C]))).``

## What I learned

The biggest thing I’ve taken away from this exercise so far is that I really need a good Factor book that covers both the language and the vocabulary. Along similar lines, Programming Erlang is a good book, but it could have spent some more time on basic programming (especially covering the provided functions in something other than an appendix).

Factor has been the language that’s been hardest to wrap my mind around so far. At the same time, it’s the one that I’ve enjoyed the most—I also think the word definitions have a sort of terse beauty. I think Ruby is probably the one that most programmers could just pick up and maintain though.

Next up, Section 1.1.7 “Square Roots By Newton’s Method”.

## Thursday, October 4, 2007

### Reading SICP in Erlang: Section 1.1.4

Ok, here’s my erlang take on Section 1.1.4 of SICP, or you can go look at my Ruby or Factor versions.

Unlike Scheme, Ruby, or Factor, I’ve got to put the code for the square and sum_of_squares functions1 into a separate file. I’m not going to explain the mechanics of the file, but we can take a look at the functions themselves.

`sicp.erl` -module(sicp). -export([square/1]). -export([sum_of_squares/2]). square(A) -> A * A. sum_of_squares(A, B) -> sicp:square(A) + sicp:square(B).``

square has an arity of 1 (it takes a single argument), and returns the value of that argument times itself. Because mulitplication only works with numeric types, it will work for integers and floats, but will fail for non-numeric arguments.

To execute these functions we need to compile the code (see line 1 below). Then we just call the function (with its module namespace) and give it an appropriate argument.

``1> c(sicp).{ok,sicp}2> sicp:square(5).253> sicp:sum_of_squares(3,4).25``

And that’s about all there is to it. Pretty simple stuff. Next up will be section 1.1.6 exercise 1.3.

1 In SICP they’re called procedures; in Ruby, methods; and in Factor, words. I just need to try to keep them all straight.