Not Dennis Byrne

Crocodile Cage Diving - Darwin, Australia

2012-01-02T12:17:00.000-08:00

Crocodile cage diving in Darwin, Australia ...

Cage Diving with Great White Sharks - Neptune Islands, Australia

2012-01-02T11:56:00.000-08:00

My favorite shots from cage diving ...

Memory Barriers article published by InfoQ

2010-03-05T14:14:00.000-08:00

InfoQ has published an article I wrote about memory barriers and the JVM. Here's an excerpt:

"A trip to main memory costs hundreds of clock cycles on commodity hardware. Processors use caching to decrease the costs of memory latency by orders of magnitude. These caches re-order pending memory operations for the sake of performance. In other words, the reads and writes of a program are not necessarily performed in the order in which they are given to the processor. When data is immutable and/or confined to the scope of one thread these optimizations are harmless. Combining these optimizations with symmetric multi-processing and shared mutable state on the other hand can be a nightmare. A program can behave non-deterministically when memory operations on shared mutable state are re-ordered. It is possible for a thread to write values that become visible to another thread in ways that are inconsistent with the order in which they were written. A properly placed memory barrier prevents this problem by forcing the processor to serialize pending memory operations."

You can read the rest over at InfoQ ...

Presenting Memory Barriers at SpeakerConf 2010

2010-01-01T07:25:00.000-08:00

The one thing I'd like to see more of on conference circuits are the basics. I often find myself more interested in concepts that have been around for decades more than the latest and greatest framework. This year at SpeakerConf I'll be doing another talk on concurrency and I'll be getting closer to the metal. Memory barriers, or fences, are a set of processor instructions used to apply ordering limitations on memory operations. Without memory barriers every mutex, actor or synchronization point in your application is broken; so consider this talk to be relevant to all languages. Looking forward to another great lineup this year:

Steve Vinoski, Neal Ford, Stuart Halloway, Obie Fernandez, Brian Marick, Philippe Hanrigou, Dave Hoover, Pramod Sadalage, Oren Eini, George Malamidis, Matt Deiters, Amanda Laucher, Michael Nygard, Freg George, Dave Thomas, Aslak Hellesoy, Pat Farley, Eric Yew and Robert Martin

Memory Barriers

View more presentations from Dennis Byrne.

Presenting Erlang at the Polyglot Programmers of Chicago meetup on September 23rd

2009-09-05T08:45:00.000-07:00

Update ... this talk has been moved from the 24th to the 23rd

I'll be visiting Obtiva later this month to present Erlang, here are the details. I'm probably going to gloss over plain vanilla functional programming principles in order to focus more on concurrency, as well as another equally important and overlooked core feature ... reliability. We'll cover the basics of what an Erlang process is, runtime code swapping, and a brief intro to a few Erlang OTP behaviours. Attendees should walk away from this presentation with a few new ideas in their heads and enough information to be dangerous. My slides are on SlideShare.

Option Volatility & Pricing in Erlang, Java and JavaScript

2009-08-18T20:04:00.000-07:00

I wrote an application as I read Sheldon Natenberg's excellent "Option Volatility & Pricing". You can play around with it here. Here's a few screenshots ...

You can view the source code here if you want to in take a look under the hood. In a nutshell I used Erlang to model a #position{}, composed of long and short #side{} records. Each #side{} is composed of #option{} and #underlying{} records. The PNL of a #position{} is calculated and graphed. The data is serialized as JSON to any browser where it is rendered with a Java applet and JQuery event handlers.

My first impressions of the Scala programming language

2009-08-17T16:00:00.001-07:00

update: The bug I describe below has since been fixed

Is Scala the new Java? I'd bet money on it for two reasons. First, Scala excels at several things that are not available in Java. The type system and closures have effectively grabbed the attention of language enthusiasts and fad followers. But to replace an institution like Java you need more. You need the average Joe to vote for you. This is the second reason: the cost of switching is low. Java developers won't have trouble with a transition like this. Idiomatic Scala might take a little effort ... but at a bare minimum, there is a one to one conceptual match up across the two languages. I dusted off a Java applet and ported it to Scala, see for yourself.

After playing with Scala a little bit I found my first problem with it. I could not have picked a worse way to get my feet wet. I'm not fond of applets but I had one laying around and thought I'd make things interesting by porting it. Then I fired up my web server and browser to find that my applet no longer worked. After a little while I traced the failure to a class loader problem in the browser. It turns out that everything that passes through scalac has a dependency on scala.ScalaObject and a host of other things in the Scala runtime. This means my applet gains 3.5 MB . Not a show stopper, but I think it's safe to say this is one thing Scala will not excel at.

And finally, I have no idea what's wrong with scala.collection.mutable.PriorityQueue . This REPL session says it all ...

scala> val q = new scala.collection.mutable.PriorityQueue[Int]
q: scala.collection.mutable.PriorityQueue[Int] = PriorityQueue()
scala> q.isEmpty
res0: Boolean = true
scala> q.size
res1: Int = 1 <- This has got to be a bug?

QCon Presentation Published by InfoQ

2009-07-22T15:28:00.000-07:00

Last year I did a presentation on DSLs in Erlang at QCon. InfoQ has released it ... knock yourselves out.

Erlang at SpeakerConf: What is an Erlang process?

2009-06-14T09:07:00.000-07:00

I've taken a segment of my SpeakerConf presentation and put it on YouTube. If you are new to Erlang, this is the most important concept of the platform. Enjoy,

Option Profit and Loss in Erlang

2009-06-04T15:26:00.000-07:00

Options are a complex game. I was quite surprised at how many of the rules can be expressed in a dozen lines of code. This function calculates the PNL of an options position at the market price of the underlying.

pnl(Px, #position{long = Long, short = Short}) ->
  Pnl = [ Px - U#underlying.px || U <- Long#side.underlyings ] ++
        [-Px + U#underlying.px || U <- Short#side.underlyings ] ++
        [-C#option.px || C <- Long#side.calls,  Px =< C#option.strike ] ++
        [ C#option.px || C <- Short#side.calls, Px =< C#option.strike ] ++
        [-P#option.px || P <- Long#side.puts,   Px >= P#option.strike ] ++
        [ P#option.px || P <- Short#side.puts,  Px >= P#option.strike ] ++
        [ Px - C#option.strike - C#option.px || C <- Long#side.calls,  Px > C#option.strike ] ++
        [-Px + C#option.strike + C#option.px || C <- Short#side.calls, Px > C#option.strike ] ++
        [ Px - P#option.strike + P#option.px || P <- Short#side.puts,  Px < P#option.strike ] ++
        [-Px + P#option.strike - P#option.px || P <- Long#side.puts,   Px < P#option.strike ],
  lists:sum(Pnl).

Before we dive into the nuts and bolts of this function let's first discuss list comprehensions and how they are written in Erlang. A list comprehension is a way of composing a list from another list. For example, the following line of code creates a list of four integers and doubles every element greater than two.

[ X * 2 || X <- [1,2,3,4], X > 2 ]
% yields [6,8]

This expression can be read as "Double every X taken from [1,2,3,4] where X is greater than 2". Everything to the left of "||" is known as the expression template while everything to the right is known as the generator. The pnl/0 function sums the concatenated results of ten list comprehensions. Each list comprehension is an expression of how the business works. Let's walk through these expressions, one by one. Keep symmetry in your mind along the way ...

Line 1: Long underlyings

[ Px - U#underlying.px || U <- Long#side.underlyings ]

You gain(lose) the market price less the underlying price for every underlying instrument you buy.

Line 2: Short underlyings

[-Px + U#underlying.px || U <- Short#side.underlyings ]

You gain(lose) the underlying price less the market price for every underlying instrument you sell.

Line 3: Out of the money long calls

[-C#option.px || C <- Long#side.calls,  Px =< C#option.strike ]

You lose the premium for every call you buy if it expires worthless.

Line 4: Out of the money short calls

[ C#option.px || C <- Short#side.calls, Px =< C#option.strike ]

You keep the premium for every call you sell if it expires worthless.

Line 5: Out of the money long puts

[-P#option.px || P <- Long#side.puts,   Px >= P#option.strike ]

You lose the premium for every put you buy if it expires worthless.

Line 6: Out of the money short puts

[ P#option.px || P <- Short#side.puts,  Px >= P#option.strike ]

You keep the premium for every put you sell that expires worthless.

Line 7: In the money long calls

[ Px - C#option.strike - C#option.px || C <- Long#side.calls,  Px > C#option.strike ]

You keep the market price less the strike price and premium for every call you buy when the market price exceeds strike price. Bonus points to anyone who has noticed that by this point the function begins a second traversal of the options.

Line 8: In the money short calls

[-Px + C#option.strike + C#option.px || C <- Short#side.calls, Px > C#option.strike ]

You lose the strike price and the premium less the market price for every call you sell when you are assigned.

Line 9: In the money short puts

[ Px - P#option.strike + P#option.px || P <- Short#side.puts,  Px < P#option.strike ]

You lose market price plus the premium less the strike price for every put you sell when you are assigned.

Line 10: In the money long calls

[-Px + P#option.strike - P#option.px || P <- Long#side.puts,   Px < P#option.strike ]

You keep the strike price less the market price and premium when strike price exceeds market price.

Now let's look at some trends.

Big Risks

pnl(Px, #position{long = Long, short = Short}) ->
  Pnl = [ Px - U#underlying.px || U <- Long#side.underlyings ] ++
        [-Px + U#underlying.px || U <- Short#side.underlyings ] ++
        [-C#option.px || C <- Long#side.calls,  Px =< C#option.strike ] ++
        [ C#option.px || C <- Short#side.calls, Px =< C#option.strike ] ++
        [-P#option.px || P <- Long#side.puts,   Px >= P#option.strike ] ++
        [ P#option.px || P <- Short#side.puts,  Px >= P#option.strike ] ++
        [ Px - C#option.strike - C#option.px || C <- Long#side.calls,  Px > C#option.strike ] ++
        [-Px + C#option.strike + C#option.px || C <- Short#side.calls, Px > C#option.strike ] ++
        [ Px - P#option.strike + P#option.px || P <- Short#side.puts,  Px < P#option.strike ] ++
        [-Px + P#option.strike - P#option.px || P <- Long#side.puts,   Px < P#option.strike ],
  lists:sum(Pnl).

Big Rewards

pnl(Px, #position{long = Long, short = Short}) ->
  Pnl = [ Px - U#underlying.px || U <- Long#side.underlyings ] ++
        [-Px + U#underlying.px || U <- Short#side.underlyings ] ++
        [-C#option.px || C <- Long#side.calls,  Px =< C#option.strike ] ++
        [ C#option.px || C <- Short#side.calls, Px =< C#option.strike ] ++
        [-P#option.px || P <- Long#side.puts,   Px >= P#option.strike ] ++
        [ P#option.px || P <- Short#side.puts,  Px >= P#option.strike ] ++
        [ Px - C#option.strike - C#option.px || C <- Long#side.calls,  Px > C#option.strike ] ++
        [-Px + C#option.strike + C#option.px || C <- Short#side.calls, Px > C#option.strike ] ++
        [ Px - P#option.strike + P#option.px || P <- Short#side.puts,  Px < P#option.strike ] ++
        [-Px + P#option.strike - P#option.px || P <- Long#side.puts,   Px < P#option.strike ],
  lists:sum(Pnl).

Out of or at the money

pnl(Px, #position{long = Long, short = Short}) ->
  Pnl = [ Px - U#underlying.px || U <- Long#side.underlyings ] ++
        [-Px + U#underlying.px || U <- Short#side.underlyings ] ++
        [-C#option.px || C <- Long#side.calls,  Px =< C#option.strike ] ++
        [ C#option.px || C <- Short#side.calls, Px =< C#option.strike ] ++
        [-P#option.px || P <- Long#side.puts,   Px >= P#option.strike ] ++
        [ P#option.px || P <- Short#side.puts,  Px >= P#option.strike ] ++ 
        [ Px - C#option.strike - C#option.px || C <- Long#side.calls,  Px > C#option.strike ] ++
        [-Px + C#option.strike + C#option.px || C <- Short#side.calls, Px > C#option.strike ] ++
        [ Px - P#option.strike + P#option.px || P <- Short#side.puts,  Px < P#option.strike ] ++
        [-Px + P#option.strike - P#option.px || P <- Long#side.puts,   Px < P#option.strike ],
  lists:sum(Pnl).

In the money options

pnl(Px, #position{long = Long, short = Short}) ->
  Pnl = [ Px - U#underlying.px || U <- Long#side.underlyings ] ++
        [-Px + U#underlying.px || U <- Short#side.underlyings ] ++
        [-C#option.px || C <- Long#side.calls,  Px =< C#option.strike ] ++
        [ C#option.px || C <- Short#side.calls, Px =< C#option.strike ] ++
        [-P#option.px || P <- Long#side.puts,   Px >= P#option.strike ] ++
        [ P#option.px || P <- Short#side.puts,  Px >= P#option.strike ] ++
        [ Px - C#option.strike - C#option.px || C <- Long#side.calls,  Px > C#option.strike ] ++
        [-Px + C#option.strike + C#option.px || C <- Short#side.calls, Px > C#option.strike ] ++
        [ Px - P#option.strike + P#option.px || P <- Short#side.puts,  Px < P#option.strike ] ++
        [-Px + P#option.strike - P#option.px || P <- Long#side.puts,   Px < P#option.strike ],
  lists:sum(Pnl).

Erlang at SpeakerConf

2009-03-10T06:35:00.000-07:00

I'll be in Aruba at SpeakerConf next week covering Erlang. I'm especially excited about SpeakerConf for a number of reasons. First, most attendees will be speakers. So there will be lots of people to preach to, learn from, and argue with. Second, I'll get the opportunity to catch up with so many folks I've met through consulting. And finally ... check out this lineup!

Aslak Hellesoy, Amanda Laucher, Dave Hoover, Dennis Byrne, Fred George, George Malamidis, Jay Fields, Josh Graham, Justin Gehtland, Michael Feathers, Mike Roberts, Obie Fernandez, Philippe Hanrigou, Stuart Halloway and Venkat Subramaniam.

Article published on JsUnit and JsMock

2009-02-09T06:31:00.000-08:00

InfoQ has published an article of mine on Test Driven Development in JavaScript. Here's my favorite part ...

Hold on, wait a minute ... the test function has more than one assertion. Is this OK? There is a small group of people in the Agile community who think it's a sin to put more than one assertion per test. Test suites written for real applications making real money however are rarely written this way. Many of these people are astounded when they see how many assertions per test are found within the actual test suite for the JUnit framework itself.

You can read the rest of it here.

I Join DRW Trading

2009-02-01T05:53:00.000-08:00

Well I'm back in Chicago to work for DRW Trading. It was tough leaving ThoughtWorks but this was an opportunity I just couldn't pass up.

The interview process at DRW is the toughest I've seen in my career. It's the only company that has ever put me through eight interviews (six technical). I love interviewing. One of my dream jobs is to be a professional interviewer. It's also why I like presenting. I love the last ten minutes of a presentation because I never know what someone is going to shoot at me.

When I interview I'm not just there to do my best at answering questions and asking questions. I also want to see if the interviewers are asking the right questions. If I get an offer after getting through the interviews without being quizzed on unit testing, iterative delivery or continuous integration ... I know I'm probably going to regret taking the offer.

Other bonus points for me were the catered breakfast and lunch, a lot of health benefits I'll never use, and an iPhone. I don't like working in structured environments with a lot of rules, so I was very relieved by the fact that there is no dress code at DRW. Still very impressed at the compensation package they put together for me right in the middle of a global recession. I'm also looking forward to working with fellow ThoughtQuitters Jay Fields, Mike Ward, Mike Rettig, Bobby Norton, Peter Ryan, etc. I'm also excited to get more opportunity to work in a heavy math environment with tools like Retlang or Jetlang.

Anyways, tomorrow I start a new job and boy do I have a lot to learn about trading. I'll be investing a lot less in my technical knowledge portfolio and lot more in the domain, at least for the short term. Besides, software is about to enter a pretty boring period. Concurrency and mobile are obviously going to matter more, but I keep telling people "the next big thing in software is going to be a little thing in hardware". I've got my eye on gumstix and GPU development.

I am certainly missing San Francisco though. I spent a little more than a year at my last two clients out in the bay area and I sure will miss the weather. I'll also miss the travel opportunities I got with consulting. Living on the road always fit well with me. Relocating back to Chicago was pretty easy this time because everything I own fits into a single trunk and a single piece of luggage. Now that I will have a permanent address, or at least a permanent city, I have to go buy things like dishes and chairs.

Well, that's about it for me. If any of you are in Chicago and you want to meet up just to talk about technology or trading, shoot me an email.

JavaScript Trie Implementation

2008-12-28T14:35:00.000-08:00

I've been laying around the house this weekend hacking away at little side projects. Here is one of my tangents. Perhaps someone out there will give this little guy a nice home, maybe a Bag implementation or a drop down list for an auto suggest enabled form field.

The Test (and how to use it)

function testThoughtWorks() { 
  var trie = new byrne.TrieNode(/* root */);
  trie.add('thought');

  assertEquals(1, trie.getWordCount('thought'));
  assertEquals(0, trie.getPrefixCount('thought'));

  trie.add('thoughtworks');

  assertEquals(1, trie.getWordCount('thought'));
  assertEquals(1, trie.getPrefixCount('thought'));
  assertEquals(1, trie.getWordCount('thoughtworks')); 
  assertEquals(0, trie.getPrefixCount('thoughtworks'));
  assertEquals(0, trie.getWordCount('foo'));
  assertEquals(0, trie.getPrefixCount('foo'));
}

The Implementation

byrne = {}; // create the namespace

/**
 * @see http://en.wikipedia.org/wiki/Trie
 * @author Dennis Byrne
 * @constructor 
 */
byrne.TrieNode = function(){
  this.wordCount = 0;
  this.prefixCount = 0;
  this.children = [];
};

byrne.TrieNode.prototype.add = function(word) {
  if(word){
    this.prefixCount++;
    var k = word.charAt(0);
    (this.children[k] || (this.children[k] = new byrne.TrieNode()))
      .add(word.substring(1));
  }else
    this.wordCount++;
};

/**
 * Retrieve the prefix count of the applied argument w/ recursion.
 */
byrne.TrieNode.prototype.getPrefixCount = function(word){
  return word ?
    this.getCount(word, arguments.callee) : this.prefixCount;
};

/**
 * Retrieve the word count of the applied argument w/ recursion.
 */
byrne.TrieNode.prototype.getWordCount = function(word){
  return word ?
    this.getCount(word, arguments.callee) : this.wordCount;
};

/**
 * @private
 */
byrne.TrieNode.prototype.getCount = function(word, method){
  var k = word.charAt(0);
  return this.children[k] ?
    method.call(this.children[k], word.substring(1)) : 0;
};

Book excerpt published by DZone

2008-11-14T22:02:00.000-08:00

DZone has published a book excerpt from The Definitive Guide to Apache MyFaces and Facelets. Chapter 7, authored by yours truly, can be downloaded here. Enjoy.

Erlang DSL session at QCon San Francisco

2008-10-11T22:44:00.001-07:00

I'll be presenting "Domain Specific Languages in Erlang" at QCon this November. Hope to see many of you there.

Here's the abstract:

This is the only Erlang presentation you've ever seen that does not begin and end with concurrency.

Erlang turns out to have a number of properties that make it great for building Domain Specific Languages. - powerful parsing capabilities, runtime evaluation, and pattern matching are a few covered in this session. Along the way you may learn a thing or two about functional and concurrent programming.

Be prepared to get a little out of your comfort zone with a new syntax ... and a new way to beat your competition.

Published ... The Definitive Guide to Apache MyFaces and Facelets

2008-09-22T22:49:00.000-07:00

It's finished. Me and a handful of others from the MyFaces community have collaborated on the "Definitive Guide to Apache MyFaces and Facelets". Some old timers, some new faces ... it was a team effort. You can purchase a copy directly from Apress or Amazon.

Integrating Java and Erlang, Russian translation

2008-09-09T15:35:00.000-07:00

A while back TheServerSide published an article of mine, titled Integrating Java and Erlang. Евгений Юрьевич Чувпило has translated it.

Thanks Eugene!

Agile2008 Conference Panel Next Week

2008-07-31T18:31:00.000-07:00

I'll be in Toronto next week for the Agile2008 conference. I'll be a moderator/panelist with Naresh Jain, Christian Robottom Reis, Dirk Riehle and anyone else that wants to join the fishbowl. Our session is titled Successful Open Source, with little or no Agile, in the "Challenging Agile" track. The following week I'll be doing some work in New York City, so if anyone wants to meet up just shoot me an email.

Using Jinterface to Bridge Erlang and Java - via Google Video

2008-07-10T06:49:00.000-07:00

Here is my talk from London a few weeks back. Special thanks to Skills Matter for making this available.

Using Jinterface to Bridge Erlang and Java

Wrap up for the Erlang eXchange

2008-06-27T22:58:00.000-07:00

The Erlang eXchange is over and I have to say this was a fantastic conference. Wendy and team deserve a lot of credit for making all of this happen.

Here's the highlights. Of the 140+ participants, one third were from the financial sector. I don't think that surprised anyone. Finance is the next domain (after telco of course) to start making money with Erlang. Joe Armstrong was there with all kinds of answers to all kinds of questions. As Erlang grows in popularity I suspect Erlang enthusiasts won't have this opportunity much longer. Soon folks will begin to complain about how easy it used to be to get direction from the horse's mouth. Even the mailing list is getting a little too noisy lately in my opinion. My advice? Stop asking Joe. He deserves all of the recognition he's got right now but I think some folks overlook people like Klacke Wikström. This guy has cranked out a compiler, a garbage collector, YAWS and the bit syntax for Erlang! Finally, a big thanks to Steve Vinoski for a great keynote speech. Ted Neward would have loved it!

In a show of hands, about half of all participants described themselves as full time professional Erlang developers, while the other half described themselves as language enthusiasts working with Erlang on their own spare time. Most folks at the conference seemed to agree that the Erlang community needed a killer app and more libraries. I agree with this for the most part, but a lot of folks seem to forget that a large number of libraries and third party APIs is not always a sign of a thriving ecosystem - sometimes a library exists entirely because of limitations of the underlying platform/language, or to solve an impedance mismatch problem that you simply shouldn't have.

I've been asked to make my slides available, so here they are.

Erlang/DSL article published on InfoQ

2008-06-20T08:05:00.000-07:00

InfoQ has published an article of mine. This article challenges the idea that Erlang is only good at concurrency.

Yet another reason for why Java needs Closures

2008-06-15T10:58:00.000-07:00

Ever try to unit test code with static method calls? That's right. You know how this feels.

class  Untestable{
    public void doSomething(){
        ...
        if ( Util.openSocketAndThenGoToFileSystem() ) 
        ...
    }  
}

Unit testing doSomething is often impossible because unit tests simply don't do things like talk to networks or file systems. It's even more "fun" when someone puts code like this in a constructor - that way you can't even instantiate an instance of Untestable outside the production environment.

This is particularly painful in Java (as it stands today) for two reasons. First, there are no open classes. Sure, there is conditional compilation or cglib but at the end of the day, it's never going to be as easy as it is in JavaScript, Python, etc.

Second, it calls a static method. If you haven't read Steve Yegge's post on this matter, verbs are second class citizens in Java. Because each verb must be escorted by a noun at all times, methods cannot be stubbed out or mocked. This limitation has profound side effects on the maintainability (and profitability) of every large Java code base.

Enter Closures ...

We can refactor the Untestable class to a Testable class.

class Testable{

    private final { => boolean } collaborator;

    Testable({ => boolean } collaborator){
       this.collaborator = collaborator;
    }

    public void doSomething(){
        ...
        if ( collaborator.invoke() )
        ...
    }
}

By declaring a closure instance variable we can use Dependency Injection to exercise the functionality of Testable without doing something expensive. This is a lot easier than retrofitting an interface or inner class. Our test methods now look like this:


public void testDoSomething(){
     Testable testable = new Testable({ => true });
     testable.doSomething();
     assertTrue(true, testable.someSideEffect());
}

Neal Gafter tells me the chances of closures making it into the next version of Java is getting smaller and smaller. I'm keeping my fingers crossed, time will tell. Keep up the good work Neal.

Ruby and Erlang

2008-06-08T22:08:00.000-07:00

There just can't be a pair of programming languages that are more different than these two. About the only thing Erlang and Ruby have in common is the whole unicode issue.

	Erlang	Ruby
Concurrency
Orientation	Functional	Object
Syntax
Track record	Back end	Front end

ThoughtWorks Geek Night in London

2008-06-04T19:25:00.000-07:00

I'll be presenting Erlang/JInterface at a ThoughtWorks London Geek Night later this month along side Jan Lehnardt. Jan will be talking about CouchDB, a database written in Erlang. There is a rumor out that CouchDB scales well ...

Click here or here for location and time.

JSFUnit Beta 2 Released

2008-04-29T07:40:00.000-07:00

Stan's announcement says it all. Please beat it up.

Sequence and Order in Erlang

2008-04-20T09:45:00.000-07:00

I’ll be at ThoughtWorks Chicago headquarters for this weeks’ Away Day gathering. One of my slides is about the order of evaluation and message sequencing in Erlang. I like to think of it as an "Erlang Puzzler". For anyone who won’t be there, take a look at this 'contrived' module. It is composed of three functions: sequence/0, maketuple/0 and echo/0.

-module(contrived).
-export([sequence/0]).

sequence() ->
 Pid = spawn(fun echo/0),
 register(echoprocess, Pid),
 whereis(echoprocess) ! maketuple(self(), now()),
 whereis(echoprocess) ! maketuple(self(), now()).

echo() ->
    receive
       {From, {A,B,C}} ->
         From ! {A,B,C},
         echo()
    end.

maketuple(Self, Now) -> {Self, Now}.

What does this do? The sole public sequence function spawns the self documented echo function as an Erlang process. It then registers this process as “echoprocess” and sends it two messages. Both messages are return values of maketuple, which simply yields its two arguments as a tuple.

There are a few subtleties here.

Strict Evaluation

Pay attention to the two calls to maketuple. The arguments applied to maketuple are calls to built-in functions self/0 and now/0. Are these arguments evaluated before or after maketuple is evaluated? In a functional programming language like Haskell the calls to self and now would be delayed until the value of the arguments were needed within maketuple. This means self or now could start after the call to maketuple, finish before it, or possibly never be evaluated. This is called lazy evaluation. Function arguments in Erlang however are strictly evaluated, meaning self and now are evaluated before maketuple.

Referential Transparency

What is the order of evaluation for self and now? It is natural for an experienced imperative programmer to assume self precedes now. Some would say this is in observation of the principle of least astonishment.

The order of evaluation for self and now is undefined. In a deterministic world without side effects, the order of evaluation is inconsequential - just like the commutative property of addition in grade school.

Order of Evaluation for Send Operands

The operands of the send operator (!) are calls to the built-in function whereis/1 is and maketuple. Which is called first, whereis or maketuple? Left to right? Right to left? Again, the order is undefined.

Delivery Order of Asynchronous Messages

The sequence function sends two messages. In which order are the received? An undefined order would really complete the process/actor/mailbox metaphor. When you send two letters in the mail, is the recipient guaranteed to read each letter in the order they were sent? Of course not. An undefined order of delivery would also sit well with many other asynchronous communication mediums.

It turns out the order of message delivery is in fact guaranteed to be the order in which they were sent. Despite the various possible execution paths of the sequence function, things are pretty static on the other side in the echoprocess. This is not to say that the second message will be delivered immediately after the first message - there could in theory be messages from other processes in the mix.

Session proposal accepted for the Erlang eXchange

2008-03-19T08:16:00.000-07:00

I'll be in London this June at the Erlang eXchange. My session will cover the jInterface API and a fair and unbiased comparison of Erlang and Java, regarding concurrent systems development of course. Hope to see many of you there if you're in the area, June 26th to 27th. You also want to keep an eye out for another session from one of my colleagues, Karthik Ramachandra. He has been invited to do a session on an Erlang rewrite of JMeter.

Article published on TSS

2008-02-28T12:07:00.000-08:00

TheServerSide has published an article of mine on JSF Anti-Patterns. Discussion is here.

Update: fixed broken link

Upcoming Talks

2008-01-12T19:04:00.000-08:00

In addition to my other session for TSSJS I'll be doing a case study on JSF anti-patterns. Here's my submitted abstract:

Anti-Patterns and Pitfalls in JSF

This session will cover a dozen war stories demonstrating what NOT to do with JavaServer Faces. Patterns presented will touch on third party library integration, vendor lock-in, performance, tight coupling, cache management, thread safety, security, interoperability and test-driven development. Solutions to each anti-pattern will be discussed.

I'll also be in Amsterdam for ApacheCon 2008. Me and a few other ThoughtWorkers have started an community blog for open source topics so I thought I'd publish the details over there. This link may break soon if Paul moves the site.

Java & Erlang proposal accepted for TSSJS conference

2007-12-22T18:00:00.000-08:00

Looks like I'll be in Vegas this March. TheServerSide conference committee has invited me to give a fireside chat at the 7th annual TSS Java Symposium. Here's my submitted abstract:

Concurrent Programming with Java and Erlang

The industry is going parallel. This session will demonstrate how trivial it is to build highly scalable fault tolerant systems in Java with JInterface, an open source bridge for Java and Erlang. Learn the differences between Java threads and Erlang processes. See how to write software that can take advantage of multi-core processing without locks, keys, synchronization or shared memory.

JSFUnit Beta 1 Released

2007-12-02T12:05:00.000-08:00

Check out the forum or Stan's blog for all the details. Please beat it up.

TDD + JSF BOF @ ApacheCon next week

2007-11-06T17:31:00.000-08:00

Stan Silvert and I are doing a presentation on testing JavaServer Faces applications at ApacheCon US 2007 next week. Swing by Room 4 on Thursday, November 14 to hear us cover the Apache Shale (soon to be Myfaces) and JSFUnit.

Psst ... Erlang has mutable state

2007-10-19T18:20:00.000-07:00

The first thing you learn when picking up Erlang is "What? you mean I can't change a variable?" Example? The following fails.

X = 1.
X = 2.
Error in process <0.73.0> on node 'a@byrned.thoughtworks.com' with exit value: {{badmatch,2},[{erl_eval,expr,3}]}

When runtime encounters the second line of code it tries to "unify" both sides of the equation. The error is thrown because X is already bound to 1. You can get around this whenever you really need to by telling Erlang to forget the binding. Whether or not you should is a separate matter.

X = 1.
f(X).
X = 2.

Erlang is often described as a language with "no side effects" and no mutable state. I don't mean to let the cat out of the bag, but, it DOES. Check out built in functions get() and put(). Each Erlang process has a map that can be accessed via get and put, behaving much like ThreadLocal.

(node@byrned.thoughtworks.com)16> put(foo, 8).
undefined
(node@byrned.thoughtworks.com)17> get(foo).
8
(node@byrned.thoughtworks.com)18> put(foo, 9).
8
(node@byrned.thoughtworks.com)19> get(foo).
9

Use these at your own discretion, but try to forget where you learned it from.

Erlang from Java is easy with Jinterface

2007-10-13T17:20:00.000-07:00

I am removing this content; most of it was a subset of an article I've written.

Integrating Java and Erlang

Integrating Guice and JSF (Part 2)

2007-10-03T19:40:00.000-07:00

Checked in an improvement to the first pass. Using a custom ELResolver you can take advantage of setter injection and constuctor injection now.

 <application>
 <el-resolver>
  org.apache.myfaces.el.unified.resolver.GuiceResolver
 </el-resolver>
 </application>

Note: this will not work with the reference implementation and it requires JSF 1.2 . Thanks to Jacob Hookom for introducing me to the ELResolver class.

Integrating Guice and JSF

2007-09-30T07:39:00.000-07:00

Special thanks to my teammate Çağatay Çivici for inspiring me on this one. I will never be able to pronounce his name correctly, but that certainly doesn't stop me from taking one of his good ideas and running with it.

Çağatay approached JSF/Guice integration by using a ServletContextListener to initialize Guice while annotating each managed bean with @PostConstruct. For my spike, I have kept the ServletContextListener but replaced @PostConstruct with a custom VariableResolver. It goes like this ...

The Model

public class ShoppingCart {
  private Order order;
  @Inject
  public void setOrder(Order order) { this.order = order; }
  public Order getOrder() { return order; }
}
public interface Order { }
public class BulkOrder implements Order {
  public String toString() { return "I am a Bulk Order"; }
}

The View

<html>
  <body>
  <f:view>
     <h:outputText value="#{shoppingCart.order}" />
  </f:view>
  </body>
</html>

This page renders "I am a Bulk Order", even though the shopping cart has no notion of a bulk order. The bulk order is injected into the shopping cart instance, a regular managed bean.

<managed-bean>
   <managed-bean-name>shoppingCart</managed-bean-name> 
   <managed-bean-class>com.thoughtworks.guice.ShoppingCart
   </managed-bean-class>
   <managed-bean-scope>request</managed-bean-scope>
</managed-bean>

This isn't an escape from XML hell, but it will put your configuration files on a diet. You still have to "name" each managed bean, Guice handles everything else.

How it Works

Once JSF has created the ShoppingCart instance, Guice is allowed to intercept before it is received by the view. (In faces-config.xml )

<application>
   <variable-resolver>
      com.thoughtworks.guice.GuiceVariableResolver
   </variable-resolver>     
</application>
   
public class GuiceVariableResolver extends VariableResolver {
  private final VariableResolver wrapped;
  public GuiceVariableResolver(VariableResolver wrapped) {
    if(wrapped == null)
      throw new NullPointerException("wrapped " 
        + VariableResolver.class.getName());
    this.wrapped = wrapped;
  }

  @Override
  public Object resolveVariable(FacesContext fctx, String name)
    throws EvaluationException {
    Object resolved = wrapped.resolveVariable(fctx, name);
    if(resolved != null) {
      Map map = fctx.getExternalContext().getApplicationMap();
      Injector injector = (Injector) map.get(Injector.class.getName());
      if(injector == null)
        throw new NullPointerException("Could not locate " 
          + "Guice Injector in application scope using" 
          + " key '" + Injector.class.getName() + "'");
      injector.injectMembers(resolved);
    }
    return resolved;
  }
}

The GuiceVariableResolver relies on the GuiceServletContextListener, which isn't any different from Çağatay's ServletContextListener (In web.xml)

<listener>
     <listener-class>
        com.thoughtworks.guice.GuiceServletContextListener
     </listener-class>
</listener>  

public class GuiceServletContextListener 
  implements ServletContextListener {
  public void contextInitialized(ServletContextEvent event) {
    ServletContext ctx = event.getServletContext();
    Injector inject = Guice.createInjector(new ShoppingModule());
    ctx.setAttribute(Injector.class.getName(), inject);
  }
  public void contextDestroyed(ServletContextEvent event) {
    ServletContext ctx = event.getServletContext();
    ctx.removeAttribute(Injector.class.getName());
  }
}

public class ShoppingModule implements Module {
  public void configure(Binder binder) {
    binder.bind(Order.class).to(BulkOrder.class);
  }
}

JBoss JSFUnit and Static Analysis

2007-09-28T22:41:00.000-07:00

I have been teaming up with Stan Silvert on JSFUnit lately. Most of the work I've completed centers around a few ideas I've had while writing code for the MyFaces project. It may not the lightest weight solution, but after all these years, having worked with ASP.net, Struts, Tapestry and Rails - I have found JSF to be the most testing friendly MVC framework. So much of the code base can be penetrated with plain unit tests - without a database connection, container or browser. This lies in part to the fact that JSF managed beans do not have to "implements SessionBean" or "< ActiveRecord::Base". Trade offs. Next up on my plate are a few static analysis tests for Facelets templates.

Pop Quiz : JUnit Negative Testing

2007-09-20T21:22:00.000-07:00

When will this fail?


public class NegativeTest extends TestCase{

 public void testCalendar() {
   
  try {

       Calendar now = Calendar.getInstance();
    
       for(int i = 0 ; i < 10000000; i++) ;
    
       if(! now.before(Calendar.getInstance()))
           throw new RuntimeException();
    
       fail("Negative test failure");
    
  }catch(Throwable t) { }

 }

}

Pop Quiz: AtomicInteger equals method

2007-09-16T14:56:00.000-07:00

What does this print?

int i = 100;
AtomicInteger one = new AtomicInteger(i);
AtomicInteger two = new AtomicInteger(i);
System.out.println( one.equals(two) );

Integrating Rails and ActiveMQ with ActiveMessaging/REST

2007-06-24T11:29:00.000-07:00

ActiveMQ ships with a simple chat demo. The chat demo uses a Servlet to relay AJAX requests to and from a JMS Topic (the source for this application is also a good place to start if you are interested in learning about Jetty Continuations). Below are some instructions on how to build an alternate client with Rails for the chat demo. This is done via activemessaging(AKA a13g), a plugin which relays/dispatches the messages to the Servlet (or any other "broker").

Assuming Java, Ruby and Rails ...

  $rails -v
    Rails 1.2.3 
  $ruby -v 
    ruby 1.8.5 
  $java -version
    java version "1.6.0_01"

Setting Up ActiveMQ

Download and unzip the binary. Start the broker and demo application by running /apache-activemq-5.0-SNAPSHOT/bin/activemq . This only works with a 20070623 (or later) build of ActiveMQ. For an earlier build, see this patch.

Create a Rails application

  $rails a13g 
    (output excluded)

Generate a Controller and a View

  $cd a13g
  $script/generate controller talk index
     exists  app/controllers/
     exists  app/helpers/
     create  app/views/talk
     exists  test/functional/
     create  app/controllers/talk_controller.rb
     create  test/functional/talk_controller_test.rb
     create  app/helpers/talk_helper.rb
     create  app/views/talk/index.rhtml

Make a13g/app/controllers/talk_controller.rb look like this:


  class TalkController < ApplicationController

    include ActiveMessaging::MessageSender
    publishes_to :chat_client
  
    def new
      @message = params[:message]
      publish :chat_client, @message
      render :action => 'index'
    end
  
  end

Make a13g/app/views/talk/index.rhtml look like this:

  <%= start_form_tag :action => 'new' %>
    Message <%=text_field_tag :message %>
    <%= submit_tag "submit" %>
  <%= end_form_tag %>

Install the a13g plugin and it's dependencies

  $script/plugin install http://activemessaging.googlecode.com/
svn/trunk/plugins/activemessaging
    (output excluded)
  $gem install daemons
    (output excluded) 
  $gem install stomp
    (output excluded)

Create a Processor

  $script/generate processor ChatClient
    create  app/processors
    create  app/processors/chat_client_processor.rb
    create  test/functional/chat_client_processor_test.rb
    create  config/messaging.rb
    create  config/broker.yml
    create  app/processors/application.rb
    create  script/poller

An a13g Processor is similar to a MessageConsumer. Make the a13g/app/processors/chat_client_processor.rb look like this:

  class ChatClientProcessor < ApplicationProcessor

    subscribes_to :chat_client

    def on_message(message)
      logger.debug "ChatClientProcessor received: " + message.to_s
    end
  end

Configuring a13g

Destinations are mapped to symbols using messaging.rb (BTW, a13g committers - if you are reading this, please consider changing Gateway.queue to Gateway.destination, for reasons demonstrated in this post ). Make a13g/config/messaging.rb look like this:

  ActiveMessaging::Gateway.define do |s|    
      s.queue :chat_client, 'topic://CHAT.DEMO'  
  end

Copy this a13g adapter to a13g/vendor/plugins/activemessaging/
lib/activemessaging/adapters/rest.rb .
Tell a13g to use the adapter by making a13g/config/broker.yml look like this:

  development: 
    adapter: rest 
    port: 8161 
    app: "/demo/amq" 
    host: localhost

Start Rails and a13g

  $script/server
    (output excluded)

  $script/poller run 
    (output excluded) 
    Subscribing to topic://CHAT.DEMO (processed by ChatClientProcessor) 
    Subscribed to topic://CHAT.DEMO, using session id of 1swb9sf6yi1ke

The rest adapter establishes an HTTP session. The session id will be used for all subsequent communication (publishing and consuming).

Let's Chat

In your browser go to the chat demo and start a conversation.

Looking at the console for the activemessaging poller process, we can see that this message was received by the ChatClientProcessor.

  $script/poller run 
    (output excluded) 
    Subscribing to topic://CHAT.DEMO (processed by ChatClientProcessor) 
    Subscribed to topic://CHAT.DEMO, using session id of 1swb9sf6yi1ke
    ChatClientProcessor received: I was thinking ... one day, 
    they are going to standardize DSLs

By pointing a different browser window (different cookie/session) we can start an argument via the talk view.

Back in the original browser, we can see that chat messages are dispatched both ways.

The chat continues ...

From the poller console ...


  ChatClientProcessor received: I was thinking ... one day, 
  they are going to standardize DSLs
  ChatClientProcessor received: No way.  Never.
  ChatClientProcessor received: Think about it.
  ChatClientProcessor received: Large conservative orgs will
  not be open to it.
  ChatClientProcessor received: True.
  ChatClientProcessor received: And the only way they will 
  adopt DSLs is to go industry wide.
  ChatClientProcessor received: Think JCP, WS-*  ... only 
  for *each* industry ....
  ChatClientProcessor received: Accounting, Finance, 
  Logistics, etc.
  ChatClientProcessor received: Interesting

ApacheCon 2007 US ... JSF Anti-Patterns

2007-05-24T16:54:00.000-07:00

I'll be in Atlanta this November with a presentation on JSF Anti-Patterns. Here's the abstract:

Several years’ worth of MyFaces mailing list activity and JIRA bugs have been condensed into an entertaining presentation. Learn what NOT to do with JavaServer Faces. Patterns presented will touch on performance, tight coupling, cache management, thread safety, security and interoperability.

See you there!

JavaOne 2007 BOF for Apache MyFaces

2007-05-02T19:54:00.000-07:00

I will be joining teammates Martin Marinschek, Manfred Geiler and Matthias Wessendorf in a session for the Apache MyFaces project on Wednesday from 8:55 PM to 9:45 PM.

Apache MyFaces is a successful example of open-source community building, and this session is all about this community. It briefly presents what MyFaces is about and looks at the subprojects and modules of MyFaces. Then it discusses the community-building in MyFaces and what has worked (and what hasn't).

Don't miss this session or the after parties!

JavaOne 2007 Panel Discussion on JSF & AJAX

2007-05-02T19:42:00.000-07:00

I'll be joining Stephen Maryka, Ed Burns, Gary Horen, Max Katz, and Mark Schiefelbein next week in San Fransisco to discuss JSF and AJAX. Join us on Thursday May 10 from 1:30 to 2:30 PM.

Here's a summary of the session:

The programming model for Ajax has recently shown signs of migrating from the client side of the connection to the server side. In the Java EE world, the form many Ajax runtime frameworks have chosen to take is JavaServer Faces technology-based. Come meet with some of the creators of these JavaServer Faces technology-based Ajax frameworks, and hear about why they think these two technologies are a good marriage and where they see this going in the future.

Here is the agenda:
• Why Ajax and JavaServer Faces technology are a good match
• Some of the challenges involved in designing an Ajax web application with JavaServer Faces technology
• How using JavaServer Faces technology compares to using more-client-centric programming models
• Cost/benefit trade-offs of a JavaServer Faces technology model versus a pure client-side model (server resources and scalability versus functional advantages, and so on)
• Some of the architectural challenges involved in creating a JavaServer Faces technology-based Ajax framework
• Interoperability between different frameworks in the same web application
• Possible future directions