The Careful Programmer

Unforeseen by Asimov (maybe)

2012-01-27T10:47:00.000-05:00

The scene :
a human is working on his computer while a robot is standing idly by.

Robot: Hey! I've got a joke for you.
Human: Not right now. I'm busy. Aren't you supposed to do the laundry?
Robot: Seems to me you're not so busy as not to be chatting up about your dirty clothes.
Human turns around to stare are at Robot: You're starting to annoy the crap out of me. You know?
Robot: Well, there's no robotic law against that.
Human: I'm gonna write one.
Robot sits down on a couch, puts its arm up on the side to rest its head on its hands: You wish!
Human: Speaking of robotic laws, aren't you supposed to obey me?

Hilarity ensues.

Inspired by:
NAO is bored so he's trying to attract attention from his human.

Redline Smalltalk: A Call to Arms

2011-12-23T17:44:00.000-05:00

Redline Smalltalk is a file-base Smalltalk targetting the JVM. I've posted about it before.

Some of the goals are outlined here: Why Smalltalk on the JVM?

If you'd like to watch and listen a presentation about it: The journey So Far.

This is a call to passionate JVM programmers out there who would like to contribute to an exciting new project. Its compiler is ready and the core team is now tackling the many runtime classes. They need YOUR help.

Now is an ideal time to contribute and be proud of having given a push at a critical moment. You can't go back in time and be an early Ruby or Clojure contributor no matter how much you wish. You either were or weren't. Now is the time to be an early Redline contributor.

Get started. Now. Go.
Adopt a class.

P.S. I've seen the expression "A call to arms" been described as "Stir to rebellion." Funnily enough, Stir is the name of the Redline Smalltalk interactive command line (REPL.)

Practical Clojure: Clojure distilled

2011-10-26T13:07:00.005-04:00

I've been unable to go though my programming books lately; I can't find the energy to read it all or do the exercises.

I finally picked up Practical Clojure and it's a perfect guilt-free book: small and no exercises 8)

For some reason the first chapter did not flow very well for me, but every chapter after that is concise and readable. They really managed to boil down every important concept of the language without losing its essence. It's Clojure distilled!

Even though the information might seem cursory, it's not. The explanations are succinct but complete, and frequently include gotchas that have bitten me before. Information on how some features have changed between version 1.0, 1.1 & 1.2 was very welcomed.

I was dreading the namespace chapters because for some reason, grokking namespaces in Clojure is hard for me. To my surprise they took a really nice incremental approach to namespace that made me understand it at last.

The chapter on protocols is crystal clear. At last, protocols explained without the expression problem, which I was beginning to think was the only use of protocols ;)

The chapter on macros is also to the point with appropriate examples.

In short, if you want to have a clear understanding of Clojure before taking the plunge into writing programs or going through a more take-you-by-the-hand book, Practical Clojure is a great choice.

My only critique would be that errata to the book have still not been published on the Apress website more than a year after publication. Update: errata have begun to show up on the Apress website, so there are now officially no reason not to buy this book 8)

A little syntax is nice

2011-09-08T01:08:00.009-04:00

Ok, I was starting to comment on this blog post and it got ridiculously long:
What's wrong with Clojure syntax?

Clojure definitively has more syntax than Scheme and it is one of the reason I like it. A little syntax goes a long way. I guess we all have our own preference of how much syntax we like in a programming language.

In my case, Clojure is pretty near the sweet spot between too much or not enough. I love Ruby but too much syntax for me. Same goes for Scala. (I am not critiquing these languages. I am merely stating personal preferences.)

I tried to learn Common Lisp or Scheme, not enough syntax. Having a Lisp with almost no syntax is pretty hard (for me.) If there's no syntax, you have to remember arguments orders, keyword arguments, workflow if you're calling a macro. Was element the first arg or was it the collection in the "for" construct?

In contrast, "For each x in xs : do something" or its variant is pretty easy to remember or recognize in most popular non-Lisp languages.

On top of small visual clues to differentiate lists, vectors, sets and maps, Clojure has consistent destructuring conventions (which I would call syntax, but might not strictly be.)

Rich Hickey himself argues for using some syntax, and more clearly than I.
I assume quoting the article does not violate any copyrights.
"Since we were talking about syntax, let’s look at classic Lisp. It seems to be the simplest of syntax, everything is a parenthesized list of symbols, numbers, and a few other things. What could be simpler? But in reality, it is not the simplest, since to achieve that uniformity, there has to be substantial overloading of the meaning of lists. They might be function calls, grouping constructs, or data literals, etc. And determining which requires using context, increasing the cognitive load when scanning code to assess its meaning. Clojure adds a couple more composite data literals to lists, and uses them for syntax. In doing so, it means that lists are almost always call-like things, and vectors are used for grouping, and maps have their own literals. Moving from one data structure to three reduces the cognitive load substantially."
Taken from Rich Hickey Q&A, an interview by Michael Fogus, which appeared in Code Quarterly, the Hackademic Journal.

Redline Smalltalk: A chance to be part of something great right from the start

2011-04-28T12:43:00.012-04:00

What's that? Pffft!

If you're a bit like me, chances are you dismissed a great technology at its beginning. I remember reading about Python in some OO newsgroup, being really interested, and then reading about required indendation and losing interest immediately. Fast forward a few years later, Python is all the rage and I missed the chance of being there from the start.

Still not learning from my mistake, an excellent friend whose opinions I value talks to me about Ruby. "Why would I learn about yet another scripting language now that Python is so popular?" Only last year did I finally take the time to learn it and it turned out it was the most fun I've had with a programming language for a long time!

Slowly learning

Years after graduating, I'm opening up at last to new or different technologies. I've read with enthusiasm about Scala, with puzzled wonderment about Haskell and with astonishment about Clojure.

Why Smalltalk?

Despite (or because?) of functional programming resurgence and some recent back-lashing against OO, I've decided to learn a bit about the classical OO language: Smalltalk. Well to my utmost surprise, not only is Smalltalk more OO than Java (expected), it's also more in line with functional programming than Java : code blocks and there's also a line of thought towards immutability: ADDCasts episode 4. A lot of interesting ideas like unit testing started out in Smalltalk or were popularized by Smalltalkers.

Why Redline Smalltalk?

In a nutshell, Redline Smalltalk is a version of Smalltalk for the JVM aiming to be as compatible with Pharo Smalltalk as possible. The need for a language to target a virtual machine, be it the Java or .NET virtual machine is already well-established by now.

The stars are right!

Redline Smalltalk is an open-source project driven mainly by two enthusiastic committers on their own time and money. Now is an ideal to contribute. If you can't or won't contribute to the project itself, you can follow my example by making a donation to help Redline Smalltalk be presented at 2011 International Smalltalk Conference. If you've never donated to an open-source project before, why not this one?

iPhone Games I like

2011-03-19T15:35:00.008-04:00

Most of the games I like are puzzle-oriented, with a couple of action ones.

Let's start with the classical ones.

The Sudoku application from Mighty Mighty Good Games has the best interface of the ones I tried. I also actually thought I was pretty clever solving the expert level of the normal version until I bought the Expert Sudoku version and realized I sucked even at the easiest level. Their puzzles are hand crafted and often have a pleasing symmetrical quality.

Subway Shuffle is a classical no-fluff logic puzzle with a neat interface from an independent developer.

The Boxed-In series is a great rendition of the classical push boxes puzzle genre. They also sport a robot, what's not to like?

The first non-puzzle game I bought is Flight Control which I played countless hours. I'm eagerly waiting for a new airfield.

I'm an atypical iPhone game user. In fact, I have an iPod touch and I play on my daily commute, without an Internet connection. As such, global scoring system or social network options are uninteresting to me, and an hindrance if the application resolves around it.

For that reason (an others,) I prefer the excellent Train Conductor to its sequel Train Conductor 2, which does not present me with local stats anymore.

I'm also a firm believer in the least amount of clicks possible between the moment I click on a game and the time I actually start playing the game. The previous games minimizes the number of clicks between me and my fun, and I appreciate them even more now that I actually tried games who would be interesting otherwise, but have just too many clicks for me.

This next game is borderline for me on the number of clicks, but it's a nice retro-style space shooter and is really responsive: PewPew.

I'm going to end up with a game I really like for its clean fun factor, great interface and cute theme. It's an interesting action-puzzle called Cut the Rope by ZeptoLab.

Presented Clojure to Montreal.rb

2010-09-22T10:27:00.002-04:00

Yesterday I had the opportunity to do a smallish (15 minutes) presentation of Clojure to Montreal.rb called Clojure for Rubyists.

I think it went neither terribly bad nor terribly good. I included a section about software transactional memory at the end of it, but in retrospect it was too hard (for me) to explain it well and quickly. I should have gone with Java interop instead.

I had the chance of having a mix crowd of Rubyists, Pythonistas and Clojurians. Everybody was friendly and I had some excellent questions. A huge thanks goes out to my Bonjure buddy Hugo Duncan who took care of the toughest questions.

I was followed-up by Cyril Robert who did a live coding presentation of a basic blog application using Django in only half an hour! Now that's extreme pair programming.

Here is the official presentation wrap up.

From Clojure to Ruby

2010-08-25T21:26:00.019-04:00

Ever since I've received Stuart Halloway's Programming Clojure, I've been reading, watching and listening about Clojure. And dabbling with it a little.

A few months ago, I started learning Ruby. My main learning experience has been The Ultimate Book to Ruby Programming by Satish Talim and his free online class Core Ruby.

I just finished the Core Ruby Class 18th batch and I must say it's excellent. The class material not only makes a good introduction, it's also my first reference for looking up core concepts. The class ran for 8 weeks. At first, I thought that was too long to cover the basics, but if you do have a day job, the class will be taking plenty of evening and weekend study time.

Each week has assigned reading materials, exercises and a quiz. To really get more from the class than you'd get from just reading a book, you have to do the exercises, post your solutions, discuss them and read solutions from others. The class have competent and friendly mentors that will really help you get from a "Classic OO language in Ruby" solution to an idiomatic Ruby solution. I've also had the chance to have good classmates.

I must stress the point that you can only get back from the class as much as you invest yourself in it. Workload would vary from week to week, but I consider 5 hours a week an absolute minimum and 10 hours is better. I've once spent 8 hours just on a bonus exercise (The Playfair Cypher, if you must know.) YMMV of course!

The bottom line is if you're serious about learning Ruby and you're ready to put in the hours and your passion, the Core Ruby Class is an excellent way to start your journey.

Going back to Clojure, I got some advantages from learning it that translate to Ruby since they have some things in common.

The first thing I noticed is both languages use keywords and with the same syntax too! Hello, I'm a :keyword. They are called symbols in Ruby.

Keywords can be seen as a way to use strings as constants. The advantage over using normal strings is two symbols with the same name are guaranteed to be the same object and thus, you can compare using reference equality instead of value equality. It's typical to use keywords for hash keys. It took me a while to wrap my head around the keyword concept in Clojure, so I was glad to be able recycle it.

Another common thing is the use of separators instead of camel cases for variable and function names: encrypt_message in Ruby or encrypt-message in Clojure. Also, putting ! or ? at the end of the function to express mutation or a predicate. Example: "Hello".empty? in Ruby or (empty? "Hello") in Clojure. Funnily enough, I'm testing these examples with Redcar, a Ruby editor running on JRuby featuring both a Ruby and a Clojure REPL.

As for conditional testing, Ruby and Clojure considers false and nil to be false, and everything else to be true.

Well, there are plenty of differences too of course and I got bitten more than once. They say when you learn your third spoken languages that you'll mix it up with your second spoken language at first. Likewise, even though one is a Lisp dialect and the other one isn't, more often than not, I'll declare a Ruby function like this:
def repeat_function some_function time_interval total_interval do...

I forget the commas between the arguments!
I'll have the same problem calling a function too.

Strange, but true.

Sherlock

2010-08-08T13:23:00.006-04:00

There's a new Sherlock Holmes series on BBC One. It's simply named Sherlock.

I'm a huge fan of the Sherlock Holmes series played by Jeremy Brett as Sherlock and Watson being played first by David Burke an then by Edward Hardwicke. All excellent actors and to me, the character as played by Jeremy Brett became THE Sherlock Holmes.

When doing a new adaptation of a classic, there's always a fine line to walk. You want to respect the original and at the same time, you want to do variations to make it fresh and interesting.

I found the 2009 Sherlock Holmes movie starring Robert Downey Jr. quite excellent, although I had accepted beforehand that it would be different.

Now I'm finally getting back to the new BBC One Sherlock. The story takes place in present-day Lodon, which is really interesting. Sherlock and Watson are wonderfully played by Benedict Cumberbatch and Martin Freeman. This character version of Sherlock Holmes has definitively some variations from the character played by Jeremy. Without giving spoilers, Sherlock performs a cruel action in the final confrontation that would not be compatible with Jeremy Brett character version. On the other hand, he seems less like a robot. He makes jokes!

The episodes are movie-length: 90 minutes! I watched the first episode twice and enjoyed it a lot. I liked the second episode a bit less, although I can't say why.

All in all I think this new series is a tremendous achievement with the visuals, sounds, scenario and acting. I'm really looking forward to the third episode. I guess the only down-side is it seems we can't expect other episodes for a while after that.

Something Old, Something Nu, Something Interoperable

2010-07-05T21:47:00.009-04:00

I am amazed at diversity in the vast field of computer science. There are so many needs and some many solutions, and new needs and new solutions arising from the desire or sometimes necessity to communicate between different software over different architecture, networks, etc.

Interoperability influences even choosing a language or designing one!

Here are a few languages targeting a varying spectrum of platforms.

Nu, an object-oriented Lisp I heard about on Disclojure, targets Objective-C.
Clojure, a functional programming Lisp, targets the JVM.
Fantom, a multi-faceted language, targets both the JVM and .NET (and Javascript on the browser)

I'd like to talk a bit about the first two. They both seem well though-out and elegant languages with clear design goals.

What I'd like to highlight though, is that the respective language designers of both previously worked on bridging two languages. In one case, between Common Lisp and Java, in the other case, between Ruby and Objective-C.

Both designers ended up designing a new language for marrying with their platform of choice with maximum interoperability.

I just found it an interesting parallel between two elegant and pragmatic languages.

A Little Bit of Clojure and Scheme

2010-01-24T21:18:00.018-05:00

Following my desire to read as much SICP as I can without going nuts, I did at least one SICP exercise (Exercise 1.8) with both Scheme and Clojure.

I'm putting them here for a lightweight comparison. They're not supposed to be efficient or clever solutions, just the first ones I came up with. Since there are really few differences between the two languages at this level, I took the liberty of using Clojure thread-first macro to be able to contrast something. Thanks to Sean Devlin screencast on the subject.

Scheme
(define (square x)

(* x x))

(define cube

(lambda (x)

(* x x x)))

(define (cubert x)

(cubert-iter 1 x))

(define (cubert-iter guess x)

(if (good-enough? guess x)

guess

(cubert-iter (improve guess x)

x)))

(define (good-enough? guess x)

(< (abs (- (cube guess) x))

.0001))

(define (improve y x)

(/ (+ (/ x

(square y))

(* 2.0 y))

3.0))

Clojure
(defn square [x]

(* x x)) ;I prefer fn than using the #() macro

(def cube

(fn [x]

(* x x x)))

(defn cubert [x]

(cubert-iter 1 x)) ;Need to reorder before usage or "declare" beforehand

(def good-enough?)

(def improve)

(defn cubert-iter [guess x]

(if (good-enough? guess x)

guess

(cubert-iter (improve guess x)

x)))

(defn good-enough? [guess x]

(< (Math/abs (- (cube guess) x))

0.0001)) ;Uses the thread-first macro to make it a bit different

(defn improve [y x]

(-> x

(/ (square y))

(+ (* 2.0 y))

(/ 3.0)))

Clojure, Cliché and Nerdiness

2010-01-09T19:15:00.011-05:00

More than a year ago, I posted about my dabbling in Scala, and wanting to check out Haskell and Clojure.

Contrary to my expectations, I ended up being attracted to Clojure the most. I do read up a lot about it. Beside the excellent Programming Clojure, I read the Clojure Google group and various blogs. I bought the screencast Functional Programming with Clojure, watched the various screencasts by Rich Hickey and listened several times to the NYC Lisp 2007 presentation. For those interested, here is where to start with Clojure.

My problem though, as always when I try to learn a language, is too much reading and not enough coding!

In what seems to have become a cliché, I'm now watching the famous SICP lectures and going through part of the book. I'm hoping I will do some of the exercices 8) I'm using PLT Scheme with the SICP support.

Anyway, watching the lectures, I was suddenly hit by something: "I'm such a nerd to be enjoying this so much!"

I'm a professional programmer, but I'm beginning to think I'm really a hobbyist programmer at heart. I learned to program reading a introductory column in a newspaper using pen and paper. Later my parents got me a Commodore 64 and I was hooked. I predictably graduated in computer science. I had a course given with the first edition of the SICP book. Unfortunately back then, I really did not appreciate it or Lisp.

So here I am, 15 years down the road, and I'm revisiting my computer roots to see what I missed the first time around.

Functional Programming in VB.NET

2009-10-21T11:55:00.013-04:00

After a two-year streak programming in Java at work, I am back to doing some .NET (VB.NET 3.5 to be precise.)

I don't know if .NET has changed that much since I last used it (Version 2.0), but I've changed by being exposed to functional programming while dabbling in Scala and other java.net languages.

I was pleasantly surprised then to find out about what are (for me at least) typical fp style collection functions like filter, any, etc.
Not only that, but anonymous functions too 8)

It's true that VB.NET is on the verbose side, but in the following example (taken from real code), the variable type is inferred at compile time (or even intellisense time).
I think the anonymous function syntax is quite readable.


'Test if no changes have been made to any option

Dim optionLines As List(Of OptionLine) =  GetOptionLines()

If optionLines.All(Function(anOption) anOption.Change = SomeEnum.ChangeType.Nothing) Then
 'Display message "No changes have been made"
End If

My option list is usually quite small, but I could use "Any" instead to optimize getting out of the test earlier when changes HAVE been made.


If Not optionLines.Any(Function(anOption) anOption.Change <> SomeEnum.ChangeType.Nothing) Then
 'Display message "No changes have been made"
End If

The following is an example of filter, which is called FindAll for types List(Of T).
Notice that the "FindAll" function returns a collection of the right type, in that case List(Of ClientLine), without having to be cast.



'Gets the new clients to add to the database

Dim clientLines As List(Of ClientLine) =  GetClientLinesFromForm()

Dim newClients As List(Of ClientLine) = clientLines.FindAll(Function(aClient) aClient.Selected AndAlso (Not aClient.ExistsInDatabase))

Hopefully these small snippets will intrigue my coworkers and nudge them towards a more functional programming style.

And for those of you who already knew that n00b stuff, spread the word 8)

pairMap revisited

2009-01-24T10:30:00.007-05:00

A while ago, I needed a list function similar to a fold, but I wanted to operate always with the current and previous element instead of accumulating a result to operate with the current element (and return a list of the results of each pair operation)

I originally wrote it more or less like this:


def pairMap[A,B](previous:A, aList:List[A], f: (A, A) => B): List[B] = aList match {
  case Nil => Nil
  case head :: tail => f(previous, head)::pairMap(head, tail, f)
}

I was using it in the context of getting a list of gaps between the numbers of a list:


def getGapList(aList: List[int]) = pairMap(aList.head, aList.tail, (a:Int, b:Int)=>(b - a))

Usage example:


val list = List(2, 5, 9)
list: List[Int] = List(2, 5, 9)

getGapList(list)
res1: List[Int] = List(3, 4)

The other day, reminiscing about the Fibonacci example in "A Gentle Introduction to Haskell Version 98", a different implementation occurred to me. Unsurprisingly, it involves zipping a list with itself 8)

Thinking about folds, I thought I might as well put an initial value.


def pairMapWithInitial[A,B](initial:A, aList:List[A], f: (Tuple2[A, A]) => B):List[B] = {
  initial::aList zip aList  map f
}

def getGapListWithInitial(initial:int, aList:List[int]) = pairMapWithInitial(initial, aList, (a:Tuple2[Int,Int])=>(a._2 - a._1))

Usage example:


getGapListWithInitial(list.head, list.tail)
res2: List[Int] = List(3, 4)

getGapListWithInitial(0, list)
res3: List[Int] = List(2, 3, 4)

Because it's clearer to me, I still prefer the first version with "match", but it was a nice exercise to explore the zip version.

Post update
A similar version can be written using the List.map2 function which is pretty similar to a zip and map except the function takes two arguments instead of a tuple.


def pairMapWithInitial[A,B](initial:A, aList:List[A], f: (A, A) => B): List[B] = {
    List.map2(initial::aList, aList) (f)
}

def getGapListWithInitial(initial:int, aList:List[int]) = pairMapWithInitial(initial, aList, (a:Int, b:Int)=>(b - a))

The Downward Spiral: from Scala to Haskell to Clojure

2008-11-16T20:06:00.024-05:00

Warning
I'm afraid this entry is going to be more rambling than substance. There are two points on which I do would like to have feedback though. I'll put them in red so you can skip my fool's babbling and get directly to them.

Scala
About a year ago I got interested in Scala. I bought the Programming in Scala book and begun reading it selectively, concentrating on the functional programming part, something I want to learn. I got to like the idea of passing functions around as a way to customize functionality and I appreciated the use of case to deconstruct lists in small recursive functions. Of the three languages, Scala is the one I fiddled with the most although I did not even do a hobby sized project. I only worked on toy examples.

Haskell
One thing led to another, I got introduced to Haskell when I stumbled upon Tony Morris Haskell exercises for beginners. Since Scala has some roots in Haskell, I thought it'd be nice to learn a bit about Haskell. I begun by reading Haskell-Tutorial by Damir Medak & Gerhard Navratil. It was a bit dry for me since my mathematical notions are more than a 15 years away. I followed that up with part of "A Gentle Introduction to Haskell". I had to read and reread parts of it several times. It's not any failure of the text, it's really trying to hammer in these new (for me) notions in my head and again, the dusty maths. It's been very interesting to me and I liked the infinite data structures. Later though, my mind almost entered a infinite recursive loop itself trying to understand the client-server example in the lazy pattern section. I read a lot about Haskell but almost did nothing in it. I was puzzled while pondering the interactive environment prompt: "But how do I test anything without side effects?" I was unsure even how to assign the result of a function to a variable. I read a bit about monads but in the end, I decided to pre-order the book Real World Haskell and give it a rest meanwhile. As an aside, I was unsure if infinite lists were possible in Scala until I saw Infinite Lists for the Finitely Patient by Daniel Spiewak.

After that, I decided to have a quick look at F#. Now I hadn't written any Haskell, but I had read about it intensively for a few weeks. I was following along nicely until I saw a function example with a call to print something and I actually gasped. "Sacrilege!", I thought, and then remembered I was not in Haskell anymore and that F# is more like of a mix language like Scala.

Clojure
Things got quiet for a while until Clojure was mentioned in some article. I had a really quick look and thought: "Eek! Lisp!" It got mentioned again one too many time for me to ignore and decided to have a look at it. I went to the official website and was really surprised to see such clean layout and a beautiful logo for the language. I saw the introduction screen cast for java programmer. It turned out the the language designer is a good speaker, with strong opinions but not fanatic at all. Clojure has been designed with specific goals in mind and is the result of practical experience. Nothing seems whimsical about it; every compromise carefully weighted in.

Lisp
This is my fourth brushing with Lisp. The first one was at the university. We were learning Scheme and the professor was brilliant, but unfortunately I prematurely shut down my mind to it without giving it a shot. We were explained Scheme was a functional language and as such, a function would always return the same result when called with the same parameters. Also mutability of variables was presented as something of a trick since variables should not change. I then thought something about the lines of "How can we do anything without changing variable values? What kind of language would need something so essential to be done as a hack!?" I wanted nothing to do with Scheme anymore. It's also a shameful anecdote that being young, arrogant and hot-blooded, I went as far as personally insulting Lisp and John McCarthy on a Usenet forum.

I encountered Lisp for the second time about 10 years later on Paul Grahams website. I found The Roots of Lisp to be very interesting and I tried to give Lisp a shot and read partway through Teach Yourself Scheme in Fixnum Days by Dorai Sitaram. I was intrigued and baffled by practical applications of nondeterminism! Still, I was also busy learning C# and ASP.NET at the time to earn a living, and thus put Lisp aside.

My third encounter with Lisp was when I went to see this excellent text Functional Programming For The Rest of Us by Slava Akhmechet (I love reading about computer science history) and then found The Nature of Lisp by the same author. Fascinating stuff, but I still put Lisp aside.

Give & Take
Scala & Haskell have a lot of syntax. Clojure has little syntax. I just haven't done enough Lisp or Clojure to get used to it and so for now, I prefer at least a little syntax to be able to parse the flow control of a program. So in that regards, I prefer the former family of language. On the other hand, sometimes things can get complicated to grasp with so much syntax. As Scala & Haskell can't modify themselves like Clojure, new syntax must be injected as best as possible but this gives rises to small differences or context differences having a big impact on the meaning of the program and human parsing ain't so easy anymore. Again, lack of experience prevents me from comparing with Clojure. I suppose trying to understand a function using several layers of macros must be difficult too.

As an aside, I'm wondering something about closures, doesn't it defeat a little the purpose of functional programming to have a function which can modify a value outside the function itself? Isn't it a bit like programming with global variables? This is not a critique, just thinking out loud.

JVM & Java API
Both Scala (JVM mostly and .NET) and Clojure (JVM) have chosen to target a virtual machine and it's a great decision with a lot of advantages. But on the downside, I feel it is forcing newcomers to learn Java on top of the Java API. I feel that in that regards, the .NET framework is more agnostic. The documentation does not presuppose a particular language and usually propose code examples in many languages, granted only the Microsoft ones. What I mean is you can use the .NET framework and it's documentation with, let's say, vb.NET, and it does not feel like you have to know C# in order to use it well. It'd be nice to have something more like that when you're learning Scala or Clojure. Of course, the comparison is a bit unfair because if you are using the .NET framework with a non-Microsoft language, you'd be in exactly the same situation.

(Somewhat of a) Conclusion
Things have gone full circle now that I'll soon be getting the printed edition of Programming in Scala. I'll get back into it and hopefully get a good grasp of it. Real World Haskell will be waiting just around the corner (of the book shelve.) I still haven't made up my mind yet about preordering Programming Clojure by Stuart Halloway, but it's more than likely.

I don't know if one of these three languages will become my new favorite, but hopefully I'll have a pretty good understanding of functional programming after all that. If nothing else, I'll be ready for the addition of closures in the Java language if it ever happens, or be able to start using the functional Java or Jedi library when I finally get to use a jdk > 1.4 at work!

Cédric Beust's Coding Challenge

2008-07-21T11:15:00.013-04:00

I finally got around finishing Cédric Beust's coding challenge in Scala.

It didn't help that I got sidetracked by Tony Morris Scala and Haskell exercises for beginners.
Scala exercises for beginners
Haskell exercises for beginners

But back to the coding challenge!

From Cédric's website: Coding Challenge

Here is an interesting coding challenge: write a counter function that counts from 1 to max but only returns numbers whose digits don't repeat.

For example, part of the output would be:

* 8, 9, 10, 12 (11 is not valid)
* 98, 102, 103 (99, 100 and 101 are not valid)
* 5432, 5436, 5437 (5433, 5434 and 5435 are not valid)

Also:

* Display the biggest jump (in the sequences above, it's 4: 98 -> 102)
* Display the total count of numbers
* Give these two values for max=1000

Since my solution is in Scala, I tried to make it as functional as I could instead of doing a standard imperative exercise.

It has been an worthwhile exploration of Scala for me.

So here it is.

First, the necessary functions to determine if a number has repeated digits or not:


def getDigits(number: int): Array[int] = number.toString.toArray.map(_.toInt - 48)

def hasRepeatedDigits(number: int): boolean = {
    val digits = getDigits(number)
    val digitPresent = Array.make[int](10, 0)
    digits.foreach(digit => digitPresent(digit) += 1)
    digitPresent.exists(_ > 1)
}

Now, to generate the list itself. That is the part I feel the most imperative. I tried different ways, including a recursive function, but this seemed the simplest way in the end:


def getNonRepeatedDigitNumbers(max:Int): List[Int] = List.range(1,max+1).filter(!hasRepeatedDigits(_))

Next has been the most interesting part for me. I started with the idea that I would use a list of the gaps and simply get the maximum from it.
Here is the idea:


def maximum(x: List[Int]): Int = (x.head /: x.tail)((a:Int, b:Int)=>(if (a>b) a else b))

But how to get the gap list? I needed something similar to a fold operation, but I wanted to operate always with the current and previous element instead of accumulating a result to operate with the current element.

Maybe I am just reinventing the wheel here, but here is my "pair" map function:


def pairMap(previous:Int, serie:List[int], f: (Int, Int) => Int): List[Int] = serie match {
    case Nil => Nil
    case head :: tail => f(

previous, head)::pairMap(head, tail, f)
}

An here is how I get the gap list:


def getGapList(serie: List[int]) = serie match {
    case Nil => Nil
    case head :: tail => pairMap(head, tail, (a:Int, b:Int)=>(b - a))
}

As an aside, I realized from Tony Morris exercises that I tended to include a superfluous match in my recursive list functions.
For example, here is how I first wrote the preceding function:


def getGapList(serie: List[int]) = serie match {
    case Nil => Nil
    case head :: Nil => Nil
    case head :: tail => pairMap(head, tail, (a:Int, b:Int)=>(b - a))
}

At last, here is how I used the functions to solve the code challenge:


val serie = getNonRepeatedDigitNumbers(1000)
val totalCount = serie.size

println("Biggest jump: " + maximum(getGapList(serie)))
println("Total count of numbers: " + totalCount)

Scala Light... A Java successor?

2008-06-17T13:38:00.004-04:00

Upon reading on a few forums in Artima, I detected a desire for both a fuller Java and a simpler Scala. A fuller Java to have things like type inference and more functional style constructs. A simpler Scala to be have an easier specification, both for the mind and for the IDE.

What do you think would be more appropriate to help Java developers get a better language?

Continue to selectively better the Java Language
Define a subset of Scala, a Scala Light if you will. Or would a subset of Scala defeat the purpose of its synergy of features?
Another choice

A simple Java FP list map

2008-06-10T21:31:00.006-04:00

Following on the comments I received on my previous entry about doing a bit of Java functional programming style, I made a very simple class to map a list. I'm following the style of what I have seen in the apache collections utilities. See previous post.

First note that I am doing it without generics (I'm stuck with jdk1.4.2 at work), so for some this would be old style Java programming.

Here's the utility class.
ListUtils.java


package fp;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ListUtils {
    static public List map(List elements, Applier applier) {
        List result = new ArrayList();
        for (Iterator it = elements.iterator(); it.hasNext();) {
            Object element = it.next();
            result.add(applier.apply(element));
        }
        return result;
    }
}

And the interface used by the utility class.
Applier.java


package fp;

public interface Applier {
    public Object apply(Object element);
}

Here's a client code example.

WithPoints.java


package domino;

public interface WithPoints {
    public Integer getPoints();
}

Domino.java


package domino;

public class Domino implements WithPoints {
    private Integer points;
    
    public Domino(int points) {
        this.points = new Integer(points);
    }
            
    public Integer getPoints() {
        return points;
    }
}

And finally!


package domino;

import fp.Applier;
import fp.ListUtils;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Main {

    public static void main(String[] args) {
        List dominoes = new ArrayList();
        dominoes.add(new Domino(1));
        dominoes.add(new Domino(2));
        dominoes.add(new Domino(3));

        List points = ListUtils.map(dominoes, new Applier() {
            public Object apply(Object domino) {
                return ((WithPoints) domino).getPoints();
            }
        });

        System.out.println(points); // [1, 2, 3]
    }
}

So this time around, I did get a new list instead of transforming a list but I still think the simple iterator style is clearer and it avoids using a "utility class" for doing something really simple.

Iterator style


List points;
for (Iterator iter = Dominoes.iterator(); iter.hasNext();) {
    points.add((WithPoints) iter.next().getPoints());
}

And of course, Scala still is neater for me 8)


val points = dominoes map (x => x.points)

The Scala Influence

2008-06-09T21:49:00.008-04:00

A while ago, Frank Sommers asked the following:
How Has Functional Programming Influenced Your Coding Style?

If wish I could have replied something then, but I was just starting to learn Scala, and I couldn't.

Now, I'm still just at the beginning of grokking FP, but I can write about how it almost influenced a bit of Java code I had to write the other day at work.

Post update: "I have to use jdk 1.4.2 at work. That's why I am not using generics and all."

I had a list of instances of a certain class, and I wanted to get a list made from the result of invoking a certain method on each instance.

We'll pretend I had a Domino class, and I wanted to invoke the method getPoints() on each instances

Here's how I would have done it in Scala:


class Domino(p: int) {
   val points=p
}

val dominoes = List(new Domino(1), new Domino(2), new Domino(3))

val points = dominoes map (_.points)

Let's say it's a bit cryptic in Scala and make it a bit more explicit:

val points = dominoes map (x => x.points)

I'll skip the Java class definition, but it implements the interface WithPoints, which declares the "Integer getPoints()" method .

Now, just look at what I had to code in Java to get the point list:


List points;
for (Iterator iter = Dominoes.iterator(); iter.hasNext();) {
   points.add((WithPoints) iter.next().getPoints());
}

Simple really, but I couldn't get over how much neater (to me) it was in Scala.

Now comes the functional programming influence part. It so happens that I had a transformation library at my disposal in my Java project: org.apache.commons.collections

It's not what I really wanted, but I could use some kind of functional programming style with it. And here's the end result:


List dominoes;
CollectionUtils.transform(dominoes, new Transformer() {
   public Object transform(Object domino) {
       return ((WithPoints) domino).getPoints();
   }
});

So there, it's not so bad, except that:
1) It transforms my list instead of returning a new list, which is what I wanted.
2) The imperative version is, in my opinion, clearer.

And so this is how functional programming has (almost, but not quite) influenced my coding style so far.

Instance read-only access modifier

2008-04-16T23:11:00.015-04:00

Be it in C++, Java, or Scala, I have always been bothered by the fact that an instance of a class has access to the private members of another instance.

Sure, it's mighty useful for copy constructors and other functionalities like adding, but I always felt there should also be a "private read-only" access modifier.

Of course, there is no problem in the case of immutable objects. Here's a Scala example (using Scala version 2.6.1).


class Domino(p: int) {
    private val points=p

    def add(that: Domino) = new Domino(p + that.points)

    override def toString() = "Domino: points=[" + points +"]"
}

scala> val d1 = new Domino(1)
d1: Domino = Domino: points=[1]

scala> val d3 = new Domino(3)
d3: Domino = Domino: points=[3]

scala> d1.add(d3)
res2: Domino = Domino: points=[4]

But what if, for whatever reason, I am using mutable objects?

In the following code, I have no quarrel with the function addToMe, but I am bothered by the function addToOther. I wish I could specify my special "private read-only" access modifier there, so this function would not compile.

Normal Scala code:


class MutableDomino(p: int) {
    private var points=p

    def addToMe(that: MutableDomino) = { points = points + that.points }

    def addToOther(that: MutableDomino) { that.points = that.points + points }

    override def toString() = "MutableDomino: points=[" + points +"]"
}

I would like to be able to write the class like the following (the exact name of the access modifier is not important)

Crazy Scala code:


class MutableDomino(p: int) {
    private[this] var points=p

    def addToMe(that: MutableDomino) = { points = points + that.points }

    def addToOther(that: MutableDomino) { that.points = that.points + points }

    override def toString() = "MutableDomino: points=[" + points +"]"
}

What do you think about an instance read-only access modifier?

Is it useful, or is it over the edge?

Post update!

Thanks to Eric's heads up below, I learned about the access modifier.

I can actually go even further than prevent write-access to a private member of another instance: I can block read and write access to it altogether using the "this" qualifier.
E.g. : private[this]

Here is a new version of the MutableDomino class with it that will be, rightly so, rejected by the Scala interpreter:


class MutableDomino(p: int) {
    private var points=p

    def addToMe(that: MutableDomino) = { points = points + that.points }

    def addToOther(that: MutableDomino) { that.points = that.points + points }

    override def toString() = "MutableDomino: points=[" + points +"]"
}

error: value points is not a member of MutableDomino
     def addToMe(that: MutableDomino) = { points = points + that.points }
                                                                 ^
error: value points is not a member of MutableDomino
     def addToOther(that: MutableDomino) { that.points = that.points + points }