Arc and innovation

Some blogs and mailing lists are full of a discussion about the innovations in Arc. One partial consensus seems to be ‘to little, to late’ at least for an magnum opus. If you want to see an firework of innovation in programming languages, take a look at Wouter van Oortmerssens programming language page. You absolutely must see the visual programming examples and all the other ideas which question the fundamentals of programming language understanding. Pure genius.

Show me functional programming, I have no clue (obviously)

Functional programming is heating up. In several discussions over the blogosphere and on my blog others think I have no clue what functional programming is. After some consideration, I think they are right. I have no clue.

Well I do know what functional programming is. I’ve used it myself. But I have no clue how to do a business application in FP. Others don’t know either. They talk about Bezier curves, square roots, fix points, y-combinators, power functions or remodel FP into OO and think that’s still FP. Weird.

Suppose I need to write an application. There are customers who can buy products. Based on the customer and the products he bought he can buy other products. Those products he books do cost him money which he needs to pay to the company. I’m quite sure how to design such an application in OO, discuss it with some domain experts and write the code. I also know how to write such an application in a way that other developers in 5 years from now can read, undestand and extend the code.

But how would I write such an application in Lisp? Or Arc? Teach me.

Paul Graham is priceless

“Character sets are a peripheral matter. The only reason they loom so large in the average programmer’s life is that, though trivial, they’re an enormous time suck. Trivial + time consuming. Sounds like a good thing to postpone.”

He has absolutely no clue about unicode. I and every other Java developer has been using unicode for more than 10 years now, and beside some i18n issues, I/O and String comparisons, they are a non issue if the language supports them.

One is always a bit sheepish about writing quick and dirty programs. And yet some, if not most, of the best programs began that way. And some, if not most, of the most spectacular failures in software have been perpetrated by people trying to do the opposite.

.

This renders all the discussions lately just mood. PG has no experience with software development, engineering, maintenance, or anything else except writing cute dirty hacks in Lisp. If he does, enlighten me. His release of Arc doesn’t help.

Update: Take an advice from someone who has written real world applications.

Remembering Tada-List in 579 lines of code - not impressed

Tada-List was written in 579 lines of Rails code. Jeff of Coding Horror writes “[...], I agree with Joseph: it’s an impressive achievement, [...]“. I’m not impressed. If you write a framework for a narrow group of applications, it should be easy to write a small target application with a few lines of code. And they don’t count HTML.Top this: a game written in ZERO lines of code.

Most code is hidden in the framework. Taking it to the extreme, with XL/R and concept programming I could write TaDa List in one line of code:

tada-list

The issue remains. It’s the same with encryption. There is a message and a key. How much information is in the key and the message? If the key is “Hello World” then the message can just be “1″. If the key is “1″ then the message needs to be “Hello World”. How much code is in the framework and the application?

That aside. My biggest achivement in small code size was a 1024 bytes (the boot sector size of an Amiga) boot selector menu with color bars. Impressive if you consider we had to put all the menu text into those 1024 bytes.

Simple Java naming trick: now and today

When browsing and reading code, I often find this:

Date currentDate = new Date();

Someone needs a current date. The line is unclear what the developer really wanted to achieve. Does he want the current date or the current time? The Date class in Java is ambiguous: “The class Date represents a specific instant in time, with millisecond precision. ” and therefore should probably be called Time with Date only representing a day (the better named Time class resides in java.sql, ugh, one of the ugly decisions in Java).

Better name your variables with more meaning. Make your intentions clearer and use Calendar, which is more useful when working with dates[1]:

Calendar today = today();
Date now = now();

The implementation looks like this (use static imports) [2]:

public static Calendar today() {
	return Calendar.getInstance();
}

public static Date now() {
	return new Date();
}

Please, make your code more understandable for all the developers who follow you.

[1] You probably want to use Joda Time
[2] I know, Calendar stores the time also

Books on my shelf

As people have a need to mention Python and Javascript in mails and comments, as if I’ve never seen them beofre, I just checked my book shelf. The “Javascript-The Definitive Guide” says January 1997: Second Edition, “Programming Python” says October 1996: First Edition, “Java in a Nutshell” says May 1997: Second Edition, I’ve lost the first edition and bought the 2nd because it said “Covers Java 1.1″ on the cover, like the brand new inner classes and reflection :-)

No future for functional programming in 2008 - Scala, F# and Nu

On Lambda the ultimte there is a recent post with a language prediction for 2008, which mainly predicts the rise of functional programming and the rise of Scala in particular: “My prediction is a little bit more conservative, but I predict Scala will gain momentum, and at least one high visibility project will use Scala”. Brandon chimes in with “The most important thing to emerge from the discussion is the larger role functional programming will play. It seems like a safe bet.” A safe bet, really? I more sceptical, as written in my post about Qi4j and Scala.

The blogosphere is full of functional programming language advocates and the coming rise of functional programming in application development. But has anything changed since Lisp was invented in 1958? Functional programming languages have existed for more than 50 years now, and didn’t make any inroads into application development. What happend to the acclaimed golden age of functional programing, about which Peter Christensen writes? Will it come back? I dispute in a comment to that post that there ever was a golden age of functional programming, it was a fringe language from the beginning. There was a golden age of Fortran.

John McCarthy - no not THAT McCarthy - invented Lisp back in 1958. From there functional programming gained much appeal to programmers because of it’s clean and consistent style. Everything in Lisp is a list. Even the program itself. Because good programmers have a feel for aesthetics in programming style, they have a warm feeling for Lisp. Functional programming is also a powerful tool for software development. And developers like power. As Paul Graham writes in “Revenge of the Nerds” about power in languages with the aim to praise Lisp:

As an illustration of what I mean about the relative power of programming languages, consider the following problem. We want to write a function that generates accumulators– a function that takes a number n, and returns a function that takes another number i and returns n incremented by i.

He cites an example in Lisp, that implements an accumulator in a nice and pure way:

(defun foo (n) (lambda (i) (incf n i)))

Functional languages excel at mathematical and list processing problems. Most problems to solve in the enterprise are of a different type though. When moving to real problems then, functional programming languages get ugly as an ugly duck. With no swan in sight. Looking at examples from Implementing a blog in Common Lisp: Part 1, we see how ugly it can get. In Java land people a frustrated about XML, but see the brace chaos in Lisp, just to open a database:

; Open the store where our data is stored
(defvar *elephant-store*
    (open-store '(:clsql (:sqlite3 "/tmp/blog.db"))))

And defining a blog domain object doesn’t look very readable either:

(defclass blog-post ()
  ((title :initarg :title
          :accessor title)
   (body :initarg :body
         :accessor body)
   (timestamp :initarg :timestamp
              :accessor timestamp
              :initform (get-universal-time)))
  (:metaclass persistent-metaclass))

compared to a Groovy example:

@Entity
class BlogPost {
  String title
  String body
  TimeStamp timeStamp = now
}

or a Java one in Qi4j:

public class BlogPost {
   Property<String> title;
   Property<String> body;
   Property<TimeStamp> timeStamp = now();
}

Another example from nu, the rising functional star for Macos X. This time with the famous Currency converter example which creates a window:

(set @window ((NSWindow alloc)
               initWithContentRect:'(125 513 383 175)
               styleMask:(+ NSTitledWindowMask NSClosableWindowMask NSMiniaturizableWindowMask)
               backing:NSBackingStoreBuffered
               defer:0))
(@window setTitle:"Currency Converter")

With an equivalent example in Groovy to build a Swing UI:

def frame =
  swing.frame(title:'Frame', size:[300,300]) {
    borderLayout()
    textlabel = label(text:"Clicked ${count} time(s).",
                      constraints: BorderLayout.NORTH)
    button(text:'Click Me',
              actionPerformed: {count++; textlabel.text = "Clicked ${count} time(s)."; println "clicked"},
              constraints:BorderLayout.SOUTH)
}

Mostly equivalent with the Groovy example which is still slightly easier to read and understand, even by someone who doesn’t know Groovy. Mainly because Groovy is more expressive and not everything has to be pressed into a list (though the nu example contains more than lists as nu aims for object orientation).

In a discussion about Arc, a functional language, stevecooperorg writes about Lisp and the use of Emacs/Slime:

I’d like to write the next Viaweb, and I’d like to write it in Lisp. But if the basic language is inviting, the rest of the environment is sorta hostile; a shangri-la in a swamp.

That’s another problem of most fringe languages. People - the enterprise? - need to know too much beside the language. Using a fringe editor which most people abandoned in the 80s and “a decent knowledge of system administration” is too high a barrier.

Power is a good thing it seems. From my experience most developers can’t handle power. They misuse it. If your development team is less than 5 developers the chance is high that all of them are alpha developers. And your interviewing process was rigorous of course. Above ten and the chances are high that there won’t be only alpha coders. Power is a dangerous feature of a language then.

Do powerful languages scale? Do dynamical type reference languages, which most functional languages are, scale? Scaling in time and organisation? Does it scale from 6 months to 10 years and does it scale from 2 people to 50? I have my doubts for years and still ask anyone to show me how those languages scale. I really want to know. Others too. Manageability writes about Python and Chandler:

What I find interesting is that Chandler started as a Python project with bold claims such as “Python programs are both concise and readable, this makes it excellent for rapid development by a distributed team” and “Chandler design goals: … design a platform that supports an extensible modular architecture”. I was hoping to see this project as a testament to Python’s viability to large scale development.

The jury is still out, but I wouldn’t bet on scalability. As a project manager during the 90s two of my projects didn’t scale and had to be rewritten, one in Python and one in Perl. But it could just be me.

What happend to Haskell and Erlang, the functional hypes of 2006 and 2007? The Blogosphere has mainly lost interest in those lately. Scala and F# seem to be en vogue in our days. Arc perhaps is next in line to be en vogue. Certainly after Scala, which is next the next thing after Java as Bruce Eckel claims. What has changed from the days of Lisp 50 years ago I asked. Scala and F# are different from Haskell, Erlang - and Lisp. They build on an a proven plattform, on libraries that people know. Scala mostly on the JDK and Java ecosphere, F# on the Microsoft universe and .NET. They both are the most promising functional candidates when it gets to momentum. The transit for C# and Java developers seems to be easiest compared to other languages. Will that be enough for them breaking through into the mainstream?

Will the release of Arc, written as a pet project by Paul Graham the greatest functional rock star, help with functional programming? No, certainly not. Arc lost it’s appeal even before it was released. While waiting for the Arc blessing, people moved on to Scala, Erlang or F#.

Don’t kid yourself. There will be no rise for application and especially enterprise development in functional programming (See what happens when you use a Perl script to do your billing, not that I haven’t screwed up in the past with Java ;-) Which doesn’t mean to stop using functional programming languages. It’s fun, keep going.

Thanks for listening.

Best book on object orientation

I’ve recently started to read the best book on object oriented programming. There are other good books that deepen your understanding of OO like “Refactoring” and “P of EAA” from Fowler, “Design Patterns” from the GoF, the McConnell books, “The Pragmatic Programmer”, the OO books from Robert C. Martin and some others. All recommended to read. But the best I’ve read on OO in the last 15 years is Domain Driven Design from Eric Evans. There are a lot of deep insights about how to build your domain model and structure your objects and classes in that book. Highly recommended.

200 reader milestone - thanks

Thanks to all the regular readers of this blog for listening. I know 200 is not as many readers as others have, but I’m thankful for everyone of you (including those with comments who prove me wrong :-)

For those interested the FeedBurnger graph for 2007:

For post listed on DZone the daily readership peaks to 1000-2000.

BigDecimal money cookbook

Adding to my last post about BigDecimal and money, and why to never use double, I discovered a BigDecimal Cookbook for financial calculations. Splendid.

Update:: Found The Need for BigDecimal for money caluclations and Representing money.

Once and for all: Do not use double for money

The discussion on how to represent money in applications pops up regularly . Funny lots of people still use double to represent money. During my interviews some people use double for money. Once and for all: Do not use double. Double cannot represent all amounts of money and it has rounding problems. Use a Money class. Represent the amount with a BigDecimal in cents and use BigDecimal.ROUND_HALF_EVEN as your rounding method. Use a distribute algorithm to distribute money to severel slots without losing cents.

Read more about a money class from Martin Fowler or this TSS discussion. Anders writes about Money in .NET.

Rant off. Thanks for not using double anymore.

Qi4J the next Java? Forget Scala

Qi4J is the new kid on the block. Forget Scala (not although but because Bruce Eckel, the author who switches hypes faster than other people switch their underware, declares Scala to be the next big thing). Scala helps you solve CS problems nicely, but not business problems. Qi4j is about composite oriented programming. It’s designed to solve business problems. One of the brains behind Qi4J is Rickard Öberg, the brain behind JBoss. He is one of those geniuses who know that their cleverness hasn’t anything to do with the language they use. Other devlopers think that the tools they use make them into a genius (by association) and dismiss Java in favour of Ruby or Lisp or OCaml or Haskell or Lua. Some even think that Java spoils you for everything. What?

Another of those geniuses is Bob Lee, about whom I said in my Sourcekibitzer interview: “He wrote Dynaop, the best AOP for Java, Guice and now is part of the promising Web Beans project. A very friendly and extremly clever guy - swimming outside the mainstream with better ideas until all others get it too ;-) His style of coding looks aesthetically very pure to me and I like it very much.”[1] I guess the same thing could be said about Rickard.

Back to Qi4J. Why could Qi4J be the next Java? Qi4J tries to solve one of the holy grails of computer science: reuse. Their goal is to create applications by composing, not by writing code. Their solution is to decompose Java objects into fragments. This happens in two dimensions. Horizontally objects are decomposed into mixins. Vertically objects are decomposed into mixins, concerns, constraints and side effects. By splitting a Java class into much smaller fragments with specific roles they hope to increase the reuse of those fragments. So one does no longer write code but compose those fragments into bigger composites.

• Mixins: Containing state, e.g. Name, Person, Adress
• Concerns: Statelessm e.g. TransactionWrapper, Security
• Constraints: Checking parameters, e.g. NotNullConstraint
• SideEffects: Managing side effects, e.g. sending Mail

An example for a PersonComposite could look like this:

@Concerns({Security.class, Transaction.class})
@SideEffect({MailNotification.class})
public interface PersonComposite
    extends Person, Name, Adress, Composite
{
}

The PersonComposite is build from a Person (handling e.g. gender), a Name (handling firstName and lastName) and Adress (handling street). The extension of Composite doesn’t look that nice, perhaps they change this in the future. A developer can now use PersonComposite and call getFirstName() and getLastName() on the composite. If he creates an Employee class he can compose it the same way and reuse Name. For storing a House he can reuse Adress.

Qi4J provides standard fragments like a PropertyMixin. With this mixin your Name only needs to look like this:

public interface Name
{
    public void setName(@NoEmptyString String name);
    public String getName();

}

and Qi4J will fill in the actual state-handling code.

Why is Qi4j probably the next Java? Java is an enterprise language. It solves enterprise problems best (technical, deployment and organisational/ socialogical problems). Other languages solve time-to-market-VC-funded-startup problems best. Still other languages solve computer science problems best. The next language needs to solve my enterprise problems better than Java does, which means fixing Javas holes. One hole is reuse, one is tight coupling, one is dependencies. JavaNG needs to solve those. Does Qi4J help? I might think yes. It has nice ideas and adresses some of the Java problems I have in the enterprise. If DDD takes off, Qi4J or frameworks like Qi4J will take off too.

Qi4j has lots of other goodies I’ll explore in another post.

Thanks for listening.

[1] Beautiful code doesn’t depend on the language. I like modern art. I can see beauty in modern art. Not in all, but in some. I’ve argued with a lot of people who do not see beauty in modern art. Those people believe only using oil on canvas drawing people can create beauty. The same goes for the argument that you need a special language to write beautiful code. You do not. I believe there is beautiful Cobol code around. And I wrote such beautiful programms in 68k.