I’ve moved my blog over to steshaw.wordpress.com
This story paints a gloomy outlook for Sun Microsystems. This purchase would certainly end the “wars” between IBM and Sun over Java… One has to wonder what it would mean for the future of Java (the language, the platform, everything). At least HotSpot and the class library are open source now.
My understanding is that Microsoft are cashed up in this economic crisis. Plus they’ve even hired Neal Gafter. Microsoft hire a lot of very good guys. With Gafter over at Microsoft, I wonder if that influenced the decision to squash closures for Java… That was the dumbest move for Java. I suppose it doesn’t really matter: for me, Scala is the next Java.
I wonder if businesses will be more likely to adopt .NET rather than Java now though and really turn the tide. This global recession is turning out to be what I call The Greater Depression, some The Second Great Depression and still some other young ‘uns The Great Depression 2.0. I wonder who will come out on top? With ReSharper, Visual Studio is actually pretty good! So, no excuses – go brush up those C# skills!
I’ve been watching the WebBeans/JSR-299 specification for quite some time. After some discussion on the webbeans mailing list, the name was recently changed to Java Contexts and Dependency Injection. This removes the “dependency” on “Web” part. Since it’s effectively a new component model for Java, it didn’t make sense to restrict it to Web environments. The new name is long and not as catchy … maybe it’ll become known as JCDI.
The specification draws much from Seam and Guice and consequently Gavin King and Bob Lee. Congratulations to all involved in the specification. It’s really worth looking at particularly if you haven’t been using Seam 2 or Guice 2. I find myself particularly drawn to Guice 2. I hope they release it soon :).
I recently attended the “Introduction to Scala” course at Working Mouse. The course was run by Tony Morris with the help of Tom Adams. I had feared that the course would be a introduction to Scala with Haskell-coloured glasses … and it was just that. However, it was just this that made it interesting. I already know Scala at a basic level so a truly introductory course would have offered little. I knew that Tony was into Haskell and on one hand I wanted to come away with an idea of what a monad was and on the other hand I didn’t want to learn Haskell with Scala syntax. Luck would have it that there turned out to be just two attendees – myself and John Ryan-Brown. Tony was able to accelerate through the introductory material with help from Tom Adams. This freed us up to begin working on monads and emulating type-classes in Scala. It was a really wonderful course that I can’t do justice to in this short post. I did come away knowing what a monad was (but now I’m not quite so sure). I did learn Scala through “Haskell glasses” but that was what was really wonderful about the course.
So what are monads? Well it appears to be an “ultimate interface” with 3 special methods – return (also called unit), bind and join (where join can be derived from return and bind). My current understanding is that monads are the “ultimate iterator” but I figured I’m supposed to understand that they are an “abstraction over computation”. This is going to take a while to sink in. Here are the signatures for the 3 special methods:
return: a -> Ma
bind: M a -> (a -> M b) -> M b
join: M (M a) -> M a
In terms of List, return is cons, bind is flatMap and join is flatten. I wasn’t familiar with flatMap but it’s a more general version of map. Map can be implemented in terms of bind/flatMap and unit/cons.
List(1, 2, 3) map (n => n + 1)
List(1, 2, 3) flatMap (n => List(n + 1))
Since then I’ve been learning a little more about Haskell and Category Theory. It’s really great to have a new avenue of things to study. Haskell certainly has come a long way since I looked at it last.
Oh and the title of this post… Well it’s kind of a bad joke from day 3. After 3 days of indoctrination I realised that it was leading to the conclusion that a new breed of programmer was required – the hyper-productive monadic programmer for the 21st century. This new breed of programmer would eschew side effects and even OOP in preference to algebraic data types, type classes, implicits, higher order functions, monads and higher kinds. They would impress their friends with deep knowledge of mathematical principles and have an IQ 50 points above decent developers of today. These programmers would be trained to be 10x more productive than their imperative colleagues (coding in Java and C#) – allowing some of us to retire for a better life (perhaps as an economist or financial advisor). All that remains is to work out how much of this is hyperbole and how much sound.
I am glad to see InfoQ have posted a writeup about scaling agile teams using feature teams rather than component teams. This includes a downloadable chapter in the latest book by Craig Larman on the subject. We used to call this working vertically or horizontally. It has also been called cross-functional teams. I have always preferred to work vertically for the following reasons:
- Less people needed to reach a consensus about interfaces between layers of the application.
- It helps to give you the big picture of the application which is something that most of us developers strive to see.
This looks like a great course+book: The elements of computing systems.