“Cloud computing” is becoming such a popular buzzword that it now even has its very own backlash. Since I designed Freenet, I’ve been interested in the problem of building computing systems that can scale effectively. While Freenet focused on the storage and retrieval of information, I’ve often wondered whether something similar could be created for computation in general. The result of this is “Swarm”. Before anyone gets too excited, note that Swarm is currently just a proof-of-concept prototype, not anywhere close to being suitable for actual use.

The Heads Up Display (HUD) offers a great way to unobtrusively show transient information. This type of window is offered via Apple’s Interface Builder, but has until now, been unavailable to the Java developer. I should note that this component will be available in the next release of Mac Widgets for Java (0.9.2).

Scala has a nice functional Queue implementation as part of scala.collection.immutable. It implements the standard technique of using a pair of lists [L, R], where L is the first portion of the queue and R is the rear portion in reverse order. As a result, the head of L is the first element of the queue and head of R points to the last element of the queue. Hence both can be fetched in O(1) time. Items are enqueued from the rear end, i.e. a O(1) insert in R, while they are dequeued from the front.

Write a parser that accepts command line arguments. For each command line argument, print out true or false, depending on whether or not that value parses.

This is the fourth installment in a series of posts about making highly concurrent software easier to write in Java. Previous entries are available here: part 1, part 2, part 3. However, I aim to make it possible to follow along even if you haven’t read the previous posts.

I was trying to do some Index writing speed improvement and thought of creating a asynchronous Lucene index writer. This writer provides a addDocument() method which can be called asynchronously by multiple threads.

This is the third part in a series of articles on formal language processing in Scala, focusing on parser combinators and language interpretation. In this part I will add a nice operator syntax and support for recursive grammars to the simple parser combinators introduced in part 2 and then move on to the parser combinators from Scala’s core library.

This is the second part in a series of articles about parser combinators and implementing an interpreter in Scala. In this part I will focus on the development from simple hand-written parsers to parser combinators so that you can see how a combinator-based parser really works and utilize parser combinators to their full potential instead of treating them as merely a DSL for EBNF grammars.

There’s a dangerous trap to fall into: The belief that functional code is automatically good code. Hopefully not too many people would come out and actually claim this, but it seems to be an unstated common belief.

I have chosen four languages which together represent "Java.next": Clojure, Groovy, JRuby, and Scala. At first glance, these languages are wildly different. Clojure is a Lisp. Groovy is the "almost Java" choice. JRuby has the beauty of Ruby, and the mindshare of Rails. Scala, unlike the others, brings the notion that we need more static typing.

In my last post I described the high-level architecture of my software, how the soccer match part is divided into a client that does the work on showing the graphics and receiving input, a server that actually has all the match info and the AI process that actually acts as a client but controls more players at once. I also said my next task would be to write a small working piece of code for each task to get me started. Well, I’m still there; the main physics part is done. As an exercise to working with the BSD sockets interface in another language than C I did the physics part in Haskell, which was fun. Fun, but not easy.

The preferences widget in Mac OS X looks really nice. This sexier tab component was designed by one of the guys over at Panic for Coda, and was then rolled into OS X 10.5 (I’d link to the original blog where I read this, but I can’t seem to find it). Besides the sheer amazing fact that Apple actually incorporated an external idea (and a really good one at that), this tab component is a welcome improvement to the Tiger style preferences widget (still found, unfortunately, in iTunes 7.7).

This is the first part in a series of articles about implementing an interpreter for a simple functional programming language in Scala, using Scala’s parser combinator library.

Everyone who owns an iPhone (or who has been holding out for an iPhone 3G) is bound to be excited about a lot of the new things the device can finally do, particularly the introduction of third-party applications. This article includes full details of the APIs for DOM Events for touches and gestures with the new iPhone

The author demonstrates a clever implementation of a completely type-safe builder with a fluent interface. The post displays the power of Scala's type system and the synergy that can happen from combining object oriented and functional ideas.

Performance comparison for a small piece of logic across a number of languages. Some of the interesting findings (I emphasise - in this context) are : Java faster than C++, Java about a 100 times faster than Python / Ruby, JRuby faster than Ruby 1.9, Ruby 1.9 twice as fast as Python, Python / Ruby faster than Groovy, and PHP and Jython bringing up the rear.

I've been reading Pierce's Types and Programming Languages. I've become interested in the interactions between Parametric Polymorphism and runtime efficiency. I do have a interesting (to me :-) point at the end, but it takes a lot of introduction...

I just finished reading Tony Morris’s blog post on Scala implicits and saw the following comment: To me, implicits look a lot like global variables, which is why I don’t like them. Or maybe I missed something? Uh, yep — you missed something :) I was going to reply in the comments to Tony’s post but as per usual it became far too long, so I’m posting it here instead.

In the previous post, Arnar wrote about how to do a JSON parser in Haskell using parsec. He also mentioned that I had shown him a similar parser written in Scala, but I must admit that I stole it from the upcoming book Programming in Scala. The book is very good and I recommend it to anyone that is interested in learning Scala.

Whenever I'm doing the same thing over and over, a little background thread in my brain starts to wonder if there's a better way. Sometimes I tell it to shut up and let me code, other times I listen. In this case it took me a long time to listen, so it must have been pretty persistent. The first time I noticed it was while writing some lisp

Over the last couple of days I have been hacking around with a few implementations of a parallel map in Scala.

Now that even budget desktop and laptop computers are shipping with multi-core processors, it’s more important than ever to design programs so that they can take advantage of parallel processing. If you’re already writing software in Erlang or Parallel Haskell, then lucky you. But if you’re writing in Java (and are unable or unwilling to take up Scala), you will need to get organized.

In the last installment of “Sexy Swing App”, I’ll show you how to create a bottom bar component as defined by Apple in their Human Interface Guidelines here. There’s not much to this component, just a gradient and a compound line border that changes based on the focus state of the parent window. Below I’ve provided only the code related to the rendering of the bottom bar (i.e. not the code that lays out the bottom bar’s components).

A story of how to implement a Syntax Highlighting JEditorPane. No code shown yet, but will be if anybody is interested.

I recently started using Twitter and have become a big fan of the service. I've been appalled by the downtime the service has endured, but sympathetic because I assumed the growth in usage is so fast that much might be excused. Then I read this TechCrunch post on the Twitter usage numbers and sympathy turned to bafflement - because I'm intimately familiar with SMS Gupshup, a startup in India that boasts usage numbers much, much higher than Twitter's, but has scaled without a glitch.