Yearly Archives: 2007

JAOO 2007 – Tuesday

The day at JAOO was better than yesterday, but still not great. Maybe my expectations are too high?
Today’s JAOO conference of the honorable mentionable:

  • “Painless Persistence with Castle ActiveRecord” by Oren Eini and Hamilton Verissimo – which was a tutorial of Castle ActiveRecord. The session was fairly good – I learned some new stuff but knew most of it in advance. I like the idear of minimizing the complexity of data access logic, but I do not fancy the solution where the domain model objects are bound by attributes. I prefer the XML based solution found in for example nHibernate. It is a lot more tedious work, but the solution benefits of separation of concerns.
  • “C# 3.0 under the hood” by Mads Torgersen – this session was a good recap of something I read a while ago. I can’t recall the source, sorry. The session wasn’t as much under the hood as the title states, but still Mads delivered a compelling walkthrough of the construct of LINQ (Language Integrated Queries).
  • “Using LINQ to SQL to Access Relational Data” by Luca Bolognese – I was delighted to see that Microsoft has taken concepts from nHibernate and adopted them as their own. There are many similarities between nHibernate and LINQ to SQL, but I need to dig further into the subject to see if I should make the switch from nHibernate to full blown LINQ, with all it entitles. Alternatively I could just use the LINQ for nHibernate when it is released in version 1 in 3-6 months.

My last day at JAOO is tomorrow. Let us see what tomorrow brings. 🙂

JAOO 2007 – Monday

JAOO 2007 entrance

The keynote by Robert C. Martin “Craftsmanship and Ethics” was all about agile processes and development. You couldn’t really ague the test are not good and the developers should have the best tools available. It was one of those talks where everybody nods and goes their separate ways and continues doing what they have always done. Good talk though.

Afterwards I went to a session by Pramod Sadalage where he talked about evolutionary database design with database refactoring. Pramod Sadalage is a co-author of the Martin Fowler series Database Refactoring book which I have on my to-read-list-but-have-not-have-found-the-time.
He tragically failed to deliver a point about database refactoring until then end of the session where most had lost interest. He kept on talking about continues integration and ANT script – this is all fine, but I expected some thoughts and ideas of how to do database refactoring without loosing business value and precious development time. Give me some pointers, tools or patterns!
I certainly need to reevaluate if the database refactoring book should stay on my list.

After lunch I went to a session about the functional programming language Erlang by the inventor Joe Armstrong. He is a great speaker and was able to keep most attendee’s at the tip of their toes, due to implicit knowledge of current hardware architectures in the talk. He confidently delivered his views of how concurrent development should be done – not the Java, C++ or C# way, but as a simple construct of the programming language. Concurrency in Erlang is based on message parsing instead of share memory.

The rest of the day failed miserably for me. None of the talk I went to was enlightening, made me think or inspired new ideas. I went to “Testing Database Access Code Programmatically” by Roy Osherove, “Information cards and .Net – Cardspace” by René Løhde and “An Introduction to Spring.Net” by Mark Pollack.
Most (in truth all) of my colleagues was better at choosing sessions and they especially talk positively about the session “Beautiful Debugging” by Andreas Zeller.

The rest of the day I served Miracle beer from our very own Miracle Brewery at the JAOO conference party. Apparently developers like Miracle beer, because all 400 liters were consumed.

I am looking forward to tomorrow and hope that I am better at choosing the right/high-class sessions.

Geek Train to JAOO

I am on my way to the JAOO conference in Aarhus, Denmark with a colleague. We booked a late train and ended up on a geek train!
Addicted as we are, we logged on the Internet via our mobil phones and noticed that we were not the only ones with Bluetooth enabled laptops/mobil phones!
This was what we say.


That is pretty amazing as Bluetooth is a personal network and the range is about 10 meters.

Constrained-based assert model

The latest version of NUnit Framework (version 2.4 and forward) comes with a new constrained-based assert model, which allows you to write complex assertions relatively easy with a new syntax. The old classical syntax for assertions with static methods still works and according to the NUnit blog there are no plans to deprecate the classical assertion syntax.

Assert.AreEqual(5, 5.0);

Assert.AreSame(person, person);

Assert.Greater(7, 5);

Assert.IsInstanceOfType(typeof(ArrayList), new ArrayList());

Assert.IsAssignableFrom(typeof(ICollection), new List());

StringAssert.StartsWith("Anders", "And");

CollectionAssert.AreEquivalent(col1, col2);

FileAssert.AreEqual(stream1, stream2);

The new constrained-based assert model uses a single method on the Assert class for all assertions:

Assert.That("Anders", new EqualConstraint("Anders"));

The second parameter is the type of assertions – here an equal constraint that works on all types of data – primitives, collections, streams etc.

NUnit comes with a number of constraints covering most scenarios, but also allows you to extend the model by developing custom constraint by realizing the IConstraint interface.

public interface IConstraint
    bool Matches(object actual);
    void WriteMessageTo(MessageWriter writer);
    void WriteDescriptionTo(MessageWriter writer);
    void WriteActualValueTo(MessageWriter writer);

If the syntax of constrained-based assert model seams a bit to complex and not very reader friendly, the NUnit team has implemented a range of syntax helper classes like so:

Assert.That("Anders", Is.EqualTo("Anders"));
Assert.That("Anders", Is.Not.EqualTo("Anja"));
Assert.That("Hello World!", Text.StartsWith("HELLO").IgnoreCase);
Assert.That("make me happy", Text.Contains("make"));

Assert.That(person, Is.SameAs(person));
Assert.That(null, Is.Null);
Assert.That(new object(), Is.Not.Null);
Assert.That("", Is.Empty);

Assert.That(new ArrayList(), Is.Empty);
Assert.That(myCol, Is.Unique);

Assert.That(7, Is.GreaterThan(5));
Assert.That(2.0d + 2.0d, Is.EqualTo(4.0d).Within(.000005d));

Assert.That(myPerson, Is.InstanceOfType(typeof(Person)));
Assert.That(new EqualConstraint(), Is.AssignableFrom(typeof(IConstraint)));

Assert.That(new int[] { 4, 5, 6 }, Is.All.GreaterThan(0));
Assert.That(new string[] { "abc", "bac", "cab" }, Has.All.Length(3));
Assert.That(new int[] { 4, 5 }, Is.SubsetOf(new int[] { 4, 5, 6 }));

The change of syntax separates NUnit from other unit test frameworks and therefore separates from the common approach of creating unit tests.

I like the new syntax – It is intuitive and easy to comprehend. All change is not, but it is simple rules of evolution. The notion of constraints is also found in NMock.

SCRUM Certified Master

Yesterday I returned from Milan, Italy, after completing a great Scrum Master Certification course taught by the experienced Scrum trainer Joseph Pelrine.

Scrum is an agile project management method for managing projects with continuously changing requirements
and/or complex social and technical domains.

Joseph brought his friend Tim Mackinnon, whom is also a Scrum master and the originator of mock objects. I really enjoyed the course and learned a lot. We had some enlightening discussions during the course and social engagements in the evenings.

I highly recommend this course and the teachings of Joseph Pelrine to all whom looking to improve their ability to delivery quality solutions.