Wednesday, April 30, 2008

Functional FizzBuzz

Ok, so here's my first "real" post! It's a spin-off of the (perhaps) famous fizzbuzz/bizzbuzz test. There seems to be some consensus [1,2,3] that this kind of tests identify at least the worst developers during job interviews. When listening to one episode of Hanselminutes, I started to wonder how this would work in an interview for a company who would like to hire functional programmers.

My plan is to do some more posts on this theme in the future, but at what frequence I don't know yet. And of course I'll put other posts in between the "fizzbuzz" posts as well!

Think of this as a version of "The evolution of a Haskell programmer", but perhaps in a more "interviewish" context - that is: Does the style of a "functional fizzbuzz" say something about the person in front of me?

So, here's the first version! I call it "Imperative programmer likes Haskell" (but makes the wrong choice). It's written in literate way, so it should work to copy/paste the whole post directly into your text editor, save it (as *.lhs), and then load it into ghci or whatever you choose to run/compile Haskell programs in.

First, construct a small helper function for "divides"

> divides x m = x `mod` m == 0

Then do a simple "divide-and-conquer" solution, if we can print one "fizzbuzz", then we have solved the hardest task of this problem. As we see, the if-then-else expression doesn't really fit into the do-notation because of the indentation rules, which is the reason we have to use the block notation. The function looks a bit imperative and it's clearly abusing IO, printing directly to stdout. It would be better to collect the values before printing them, but lets take that in another post or perhaps skip it entirely..

> printOne x = do
>  {
>   if (x `divides` 3 && x `divides` 5) then print "FizzBuzz" 
>     else if (x `divides` 3) then print "Fizz" 
>     else if (x `divides` 5) then print "Buzz" 
>     else print $ show x
>  }

Now use a nice higher order function (HOF), which certainly no beginner would have found! This function takes a function of type a -> m a, the list [a] and performs the given actions on that list, returning no result. The entire type for mapM_ is: 
 Monad m => (a -> m b) -> [a] -> m ()
, where our monad m in this case is IO a

> fizzbuzz = mapM_ printOne [1..100]

The above function and its relatives are nice examples of "iterating" in Haskell. Of cource, some other languages have HOFs as well, and I think that I most likely will HOFs in other language in some later posts.

So, that's all for today folks! Challenge: Try writing some fizzbuzz's yourself in your favourite language and put them as a comment below or post them in your own blog and put a link to it in the comments.

Sunday, April 27, 2008

Welcome to Coffee Driven Development!

Hello and welcome to this novel blog, created by the developers and bloggers (and previously Chalmers students) Christian Genne and Gustaf Nilsson!

Coffee is indeed a very inspiring drink, and that is the reason for this blog's very existence. Without coffee, what would we do? From meeting over a cup of (yes) coffee, we decided to join together to create this blog. By blogging together we came to the conclusion that we will get more potential readers and more posts. Hopefully that's true :)

The next post will be a reflection over this meeting, the dialog we had and any potential conclusions we came to. We probably came to more unanswered questions than conclusions, but open questions are always interesting blog topics and maybe addressed in later posts!

And yes, if you are interesting in joining our blog, just drop a mail!

/ Team of Coffee Driven Development - Gustaf & Christian