Liquid Development

Getting Autotest to work on Windows for Ruby projects

2007-09-24T11:50:00.001+02:00

This seems blogworthy, as I have spent much longer than I wanted to find a solution.

I was trying to run autotest - of the zentest package - on a ruby project on windows, but autotest didn't seem to be able to pick up changes to my files.

I will not pretend to have understood exactly what made it work for me, but these are things that I did and that might have helped.

Setting the HOME variable:

set HOME="c:\Documents and Settings\my_username_here"

moving my project files into a lib directory and my test files into a test directory:

myproject
myproject/lib
myproject/test

going to the project directory and running autotest:

cd myproject
autotest -v

This should work. Every time I save a test file or a lib file, autotest picks up the changes and runs the tests.

thanks to Philippe Hanrigou for pointing out the right heuristics!

Year 2012

2007-08-06T16:52:00.001+02:00

According to the current growth rates in five years we will be able to buy storage for about 30 years of audio/video of our life for 100 euros.
It will be cheaper to record everything that happens to us and search it than to take notes or even think that we should be taking notes.

How is this going to change how we search/organize information?
How is this going to change our sense of identity?

Ruby Social Club night

2007-07-05T01:01:00.001+02:00

The Ruby Social Club meetups have started and they are coming on one after the other!
drop us a call if you are in Italy. We are all over the place, so don't be shy and get in touch.
This is a short report on the evening on the new RSC wiki (thanks intinig!)

the pics are heavy but I didn't want to spoil them (you'll see)

Are you still reading me?

2007-07-04T11:54:00.001+02:00

I haven't been blogging for a long looong time as I have been busy in a number of other activities.
Mainly stuff like giving some balance to my life and making up my mind for the next important steps in my life.

Apologies to all people I have not been talking to during these months. It just needed to be done.

Now I have to decide if I should go on with this blog, wrap everything up and move somewhere-else which is more representative of who I am now and what I want to do.

So.. are you guys still reading my blog? Do I still have some readers? Where are you from, what topics yuo would like me to cover?
Please, let me know so that I can take a decision.

TheRubyMine is On

2006-10-12T10:21:00.000+02:00

Finally we did it! TheRubyMine is online :-)
The big challenge now is to rally the whole community around it.. any advice on how to build deeper feeling of ownership and participation?

The Ruby Mine

2006-09-04T23:18:00.000+02:00

Whoa! I can't believe we are almost there!!! It took us a while to get our act together but here it is: TheRubyMine

The title is in english, but the content will be Italian, for the guys around here :-)

We are going to go Beta - invitation only in just a few days..

Check it out. Leave your mail. Join the Vision.

NOT Thinking in Java (tm)

2006-06-22T12:20:00.000+02:00

It has been some time now that I have been thinking about organizing some "*Not* Thinking in Java (tm)" workshops. It's not that I feel any angst towards Java per se, but attacking Java seems to be the trendy thing to do these days :-)

Forget about the Java thing, the sheep-thinking of the object culture is what bothers me. I am not denying my past, since I have also contributed in little part to create it and evangelize it. In the course of the past few years, we have gotten fat with objects and patterns and we have explored the limits of what can be done with objects.

That's the way it had to be, but I think that it is now time to explore alternatives. Lisp, Erlang, Haskell and their friends and cousins.

Yesterday I saw a nice article on functional languages. I really liked it. Extremely well written, simple and very pesuasive. Long, but light. I advise eveyone interested in the topic to print it out and read it. It's amazing how things can be different - and difficult things become easy - once you shift your point of view..

Dojo in Rome

2006-06-21T10:03:00.000+02:00

My readers will know that we are trying to shake up the italian ruby scene with the Ruby Social Club events. The next meeting in Rome will be hosted by Interact and we will have a proper conference room with projector, network and big screen.

We are thinking about some cool new presentation formats to keep everyone active and entertained.. what about the Dojo?

Invisible Rails Reference Guide

2006-06-14T15:51:00.000+02:00

Some of my friends know that I have finally decided to start having a look at Rails. I have found this fantastic reference guide by InVisible that seems to answer all my questions!

Javascript programming with MozLab

2006-06-02T15:01:00.000+02:00

Wait a minute, wasn't javascript a java-like scripting language for browser? I will not deny that this belief also kept me away from doing any firefox extension development.

Today I discovered MozLab and there is no turning back :-) You can do ubercool development on the mozilla platform with Repl (a kind of Irb on steroids.. you navigate and manipulate live objects inside the browser!!!) That's enough to tempt the Metaprogrammer in me :-) Then, of course, you have MozUnit for the TDD and agile minded.

I wonder how many other languages are deeply misunderstood out there...

On Simplicity and Execution

2006-05-17T11:50:00.000+02:00

I have recently started to use delicious, the social bookmarking system. Today I also found out about delicious networks: you can subscribe to the delicious feeds of a number of users and then see them as a single unified feed.

You can also subscribe to individual RSS feeds and be notified when someone you know and trust comes up with a new interesting link.

Why am I talking about this? I started thinking about these delicious features because back in 2000/2001 I was thinking about something quite similar from a philosophical point of view. I wanted to have a way to communicate to a network of trusted people the evolution of my interests and how I was structuring the nformation that I was getting from the internet. I was thinking about a complex trust system, modelled using graph theory. I had pieces of news moving across the graph, gaining strength as they received a thumb-up by more and more users.

I was theorizing about the rise of implicit communities, ephemeral islands in the net auto-defined by links of mutual trust and common interests.

Too much theorizing. There were overwhelming theoretical problems there. How to avoid dangerous trust-feedbacks of information within a network? How should trust be modelled? What are the dimensions of trust?

That's all academic bullshit.

Useful for after-the-fact analysis.
Useless to get started doing things.

Everybody can have a good idea. Ideas have become dead cheap.

Good executon means getting the simplest idea and get it implemented and used by people.
The rest will follow, if it still makes sense.

I need people to shake me every now and again and tell me: "Yes, it's nice, cool, fantastic! but.. what can we implement and ship right now?"

Article for Ruby Code & Style

2006-05-16T15:31:00.000+02:00

I am planning to write an article for Ruby Code & Style, so I ask you, my good readers, what kind of article would you like to see?

You can answer in the comments or on kiaroskuro AT gmail DOT com.

Grady Booch

2006-05-13T03:05:00.000+02:00

Grady Booch announced on his blog that he has health problems and he is going to undergo surgery in the very near future. Grady Booch has been one of my early software heroes and I remember seeing him at OOPSLA back in '97. I wish him all the best.

Burnt Out

2006-05-11T01:46:00.000+02:00

In the course of the past week or so I haven't been very good at answering to people I am in touch with. I apologize to you all. I continuously feel very tired and I needed a bit of a break.

I have been in touch with so many people recently.. being busy talking, planning and organizing that my body could barely catch up with my activities.

I now start feeling a bit better and I will slowly go back to my coding, networking, book writing, socializing, plotting and planning. My girlfriend might appreciate some of my time too :-)

I am afraid that if I want to keep up with this rythm I'll have to take on doing some exercising. Andrea, a friend of mine, told me that there is a group doing yoga-like practice in the evening in a park just behind the Colosseum. It sounds good and I might go with him to check it out one of these days. I have practiced meditation for a while in the past at a Buddhist School in England and I know the value of cultivating a fresh unencumbered centered mind.

20th of May Padua Presentation

2006-05-11T01:35:00.000+02:00

It's official. I am going to give a talk about ruby to a great bunch of java coders in Padua on the 20th of May.
I feel slightly nervous since it has been a long time since I gave a talk, but I think it's a great opportunity to get back into shape.

I am only afraid that 45 minutes might not be enough to do justice to the language...

Cyc Space

2006-05-10T11:13:00.000+02:00

A Map of the Cyc universe, from http://www.opencyc.org/doc/topic_map.

OpenCyc Technology - Formalizing Knowledge

2006-05-10T10:53:00.000+02:00

I have been wanting to blog this for a while now. I should really try to post some of the goodies that I have found on programmable language-resources on the web. I would also like to elicit you guys to point out more sites and libraries, especially if they happen to support a Ruby API :-)

OpenCyc is an OSS system that can be used to formalize common sense reasoning within an inference engine. The best thing is the wealth of data that comes with it. Here is the documentation, and a brief summary of its capabilities.

--
Chiaroscuro

Chiaroscuro Radio

2006-05-06T21:59:00.000+02:00

I was sure I would have never done it. I would have never posted pictures of my cat, or inflicted my poor taste on my readers.

Still, it happened. On the sidebar you can now find a link to Chiaroscuro Radio!

My musical taste has been defined at different times as:

"it sounds like they are skinning a poor cat"
"gee, they all sound the same"
"how can you like this stuff?"

Chiaroscuro Radio has been realized using Pandora, a software that can learn your musical taste. It took a few days, but now it almost always picks songs that I like.

Little Boxes in the Spreadsheet

2006-05-06T20:31:00.000+02:00

Tonight I should make the first release of Littleboxes, a micro-language (API? DSL? Lingo? dunno!) that allows you to use excel as a debugging writeboard from ruby.

You will be able to stream out Objects, Structs, Arrays, Strings, Hashes, etc.. to the spreadsheet so that you can better visualize the data you are working on.

Is there any feature that might turn out useful to you? I have still got the evening to work on it before releasing the alpha version to the italian ruby community. If you are not on the ruby-it mailing list drop me an email (kiaroskuro AT gmail DOT com) or a comment and I'll send it to you too.

In the meantime I'll leave you with some words from Littleboxes, a classic by Malvina Reynolds..

"Little boxes on the hillside,
Little boxes made of ticky tacky
Little boxes on the hillside,
Little boxes all the same,
There's a green one and a pink one
And a blue one and a yellow one
And they're all made out of ticky tacky
And they all look just the same."

and no, Malvina is not talking about Excel cells ;-)

Refactoring Emphasis in Language

2006-05-06T00:50:00.000+02:00

Language is one of the most ancient forms of knowledge encoding and transmission, yet we have so little conscious knowledge of how we can use it to achieve the communication that we want.

Words are programs, psychoglyphs running into other people's head. Shaping words means shaping active executable knowledge.

While reading " sleight of mouth" by Robert Dilts, I found a couple of very interesting concepts.

Look at the following sentences and feel the difference, although they have the same informational contant at face value:

I want to do X, but I have a problem
I want to do X, and I have a problem
I want to do X, even if I have a problem

I call "But", "and" and "even if" Emphatic Tags and they can be used to move the emphasis between:

justification, passive stance
equanimity, objective stance
drive, propositive stance

You can do a little word magick by restating sentences, while refactoring it for an emphatic change, and throwing them back with a more empowered meaning, even if you have never tried before.

The other emphasis trick is the enabler/toll stance.

Read the following and feel the different emotional effect in front of apparently identical information:

If you feel like putting some effort in it, you can do anything you want
You can do anything you want, if you feel like putting some effort in it

The sentence order makes a world of difference. The first part of the sentence sets the context, while the second part clarifies the meaning of the first one.

The if-opening sentence is a Toll Sentence. It's asking you for something, for a precondition, before giving you what you want. It's even hinting at the fact that you are not doing what is necessary. It feels like you are trying to convince someone of something.

The you-can-opening sentence is an Enabler Sentence. It offers you a wide range of options: anything you want, and it then points to the path to go and grab those options.

Executable Knowledge

2006-05-04T21:42:00.000+02:00

Gabriele is quoting from an interview to Luca Rosati (in italian):

I realized that too many time we 'reinvent the wheel'. More mature disciplines - such as biblioteconomy, but also psycholinguistics and neurosciences - have found a way to deal with this problem several decades ago...

I have to say that I haven't read the interview yet, but I am still going to comment on this quote.

It's common to hear people complaining about how Computer Science is immature compared to other disciplines, but I don't sympathise with this point of view. Other disciplines organise knowledge within a specific domain, whereas the domain of software development is the very act of organising knowledge! Executable knowledge, make no mistake, but still knowledge.

If you see things from this point of view, software development is a reflective meta-discipline. It's part of the very core of software development to change itself, its own tools, the way it models itself and the rest of the world. The discipline keeps changing because it's an highly introspective discipline, more similar to literature in this respect than to engineering. It is a discipline that talks about the world, but that mainly likes to talk about itself to reflect, evolve and change.

Software development changes as the world changes, because the way we see the world and organise our knowledge does change. I would find it worrying if it didn't.

Good Hungarian

2006-05-03T01:24:00.000+02:00

We are used to think of hungarian notation as being a bad thing. However, not many people know that what we know as hungarian notation is a perverted version of the original pure and good hungarian notation. Joel Spolsky talks about that too.

Bad-hungarian is when you prefix a variable name with type information

eg:

fWidth = fSize

the 'f' simply means float.

You can see you have type compatibilty on both sides, but it doesn't say anything about semantic compatibility. fWidth could be used as a measure expressed in metres, whereas fSize is expressed in feet!

Good-hungarian is when you prefix a variable name with semantic information

mtrWidth = ftSize

OR

metric_width = feet_size

you can see immediately that there is a problem there.

Both variables are of the same type (Float), yet they have a different meaning. The prefix difference make the error stand out clearly.

This is very useful in general, but I would argue that in ruby - with the dynamism offered by duck typing - good hungarian is very useful and we already use, without even thinking about it.

Metaprogramming your Breakfast

2006-05-02T23:03:00.000+02:00

Following on from the metaprogramming breakfast, I think someone is meta-challenging me here :-)

Twisting and Shaping DSLs using Ruby Metaprogramming

2006-04-29T15:27:00.000+02:00

I write this in response to Federico Feroldi's comment to my previous post on defining simple DSLs.

[..] while reading your article I was thinking about using the recipe name string as an object to route the messages coming from the ingredients and then catching them by implementing missing_method in the string object...
So, for:

recipe "italian breakfast" do
caffe = 1, :macchiato
end

is there a way to translate it into:

"italian breakfast".caffe(1, :macchiato) ?
[..]

Let's see:

"italian breakfast".caffe 1, :macchiato

First of all, I removed the brackets because I don't believe in brackets :-)

What Federico proposes can be done, but I am not sure I would do it this way, unless I am working only within the context of a DSL. If you want your recipe-string to accept the caffe method, then you have to override the method_missing method of the String class, which can be a dangerous thing to do if you have loaded other meta-code that overrides this method on a String or Object level.

I would rather go for a Concept Wrap Up:

Recipe("italian breakfast").caffe 1, :macchiato

where I make explicit the meaning of 'italian breakfast' by wrapping it into a Recipe object. Note that I did not use Recipe. new. I am launching a campaign against the use of new in application code, which I consider at the same level of badly used hungarian notation (because there is such a thing as good hungarian notation).

Another way I would do it is by using what I call a Conjunction:

"italian breakfast".consists_of.caffe 1, :macchiato

You will have to inject a consists_of method in the String class, which will act as a conjunction between the String and the method call. The conjunction will take the String and wrap it up in a Recipe object. The cafe method is then invoked on the Recipe object.

In both cases we have moved the handling of the method_missing from String to a custom made Recipe class.

The conjunction will be:

class String
#Recipe conjuction
def consists_of
Recipe .new self
end
end

The Recipe will start as:

class Recipe
def initialize recipe_name
    @name = recipe_name
    @ingredients = {}
    register_with_global_repository
end
def method_missing method, *args
    @ingredients[method .to_s] = args
end
    ...

The method_missing is catching the ingredients and it stacks them nicely on an hashtable. Why do we need the register_with_global_repository call, though?

Since we are working with a DSL and we are not explicitly storing a reference to a created recipes in a variable, then we get the Recipe to self-register itself with a global centralized repository. I could have made it a @@all_recipes class attribute, but I think that in this simple example it looks clearer as an external separate entity:

$RECIPES_REPOSITORY = {}

class Recipe
…
private
def register_with_global_repository
$RECIPES_REPOSITORY[ @name] = self
end
end

and finally the code to print out the recipe:

class Recipe
…
def report
    puts "to make #{@name} you should buy:"
    @ingredients.each_pair do
      |ingredient,description|
      puts " * #{Array(description).join ' '} #{ingredient}"
    end
end
…
end

What is still missing is a method to print out the recipe directly from the DSL. We would like our call to look like this:

recipe? "italian breakfast"

This snippet fully satisfies our language choice:

def recipe? recipe_name
$RECIPES_REPOSITORY[recipe_name].report
end

Our new DSL now allows us to write:

"italian breakfast".consists_of.caffe 1, :macchiato
recipe? "italian breakfast"

and to obtain:

to make italian breakfast you should buy:
* 1 macchiato caffe

The one big limitation is that at the moment you can define recipes with only one ingredient.

We get around this limitation by making the method_missing a Follow Up Method Chain:

def allow_method_chaining() self end

def method_missing method, *args
@ingredients [method.to_s] = args
allow_method_chaining
end

The trick here is that after having defined an ingredients we still have the original Recipe object ready to accept new ingredients.

You can now do:

"italian breakfast".consists_of.
                    caffe(1 , :macchiato ).
                    cornetto(1, :cioccolato)

recipe? "italian breakfast"

and get:

to make italian breakfast you should buy:
* 1 cioccolato cornetto
* 1 macchiato caffe

That was long! I think I will now go for a 1 cioccolato cornetto!

The Way of Meta - Part IV - Hijacking Local Variables in DSLs

2006-04-28T22:09:00.000+02:00

The Way of Meta

V. 0.0.4

Not long ago I have read the 'Creating DSLs with Ruby' article written by Jim Freeze, where he explains how to forge a DSL step by step, creating a new human readable formalism on top of ruby. I really enjoyed the article as it went along some of the lines of thought that I have been working on for a while.

In the article there was a point that was left somewhat open: how to allow developers using a DSL to assign values to new concepts that they define on the spot, and then get access to both these concepts and their values from within the DSL.

I realize I have been a bit vague here, so I'll give you a straightforward example. Let's say we want to define a DSL to describe the shopping list with all the ingredients needed to make a certain recipe..

Ideally we would like to write something like:

shopping_list_for "BLT sandwiches for the picnic" do
sliced_bread = 3
lettuce = 2
tomatoes = 6, :red
bacon = 4
end

The do..end block delimits a block context that gets passed directly to the shopping_list_for method.
This method should then extract the various ingredients and their quantity and description.

How can it do that? One way is to run the block within a context where those ingredients already exist as methods. This context would be a class with -for example- the sliced_bread= method overridden to accept the DSL input.

What about new ingredients that have not been specified a priori ? Your metaprogramming instincts will tell you to go for a method_missing based technique. Wrong. Unless you specify a self (or other object) in front of sliced_bread, ruby will simply assume that it is a local variable rather than a missing method. Highly annoying if you ask me, but it is necessary to avoid even worst problems and ambiguities when dealing with stuff like mixins.

You are left with these three choices:

shopping_list_for "BLT sandwiches for the picnic" do
self.sliced_bread = 3
self.lettuce = 2
self.tomatoes = 6, :red
self.bacon = 4
end

Argh!

shopping_list_for "BLT sandwiches for the picnic" do |recipe|
recipe.sliced_bread = 3
recipe. lettuce = 2
recipe. tomatoes = 6, :red
recipe. bacon = 4
end

Just a tad annoying

shopping_list_for "BLT sandwiches for the picnic" do
@sliced_bread = 3
@lettuce = 2
@tomatoes = 6, :red
@bacon = 4
end

The best so far.. you can visualize the @ as bullet points ant it is kind of ok..
Kind of.

Jim, at this point, proposes to drop the equal sign to force ruby to recognize the new keyword as a method that gets routed through method_missing.

shopping_list_for "BLT sandwiches for the picnic" do
sliced_bread 3
lettuce 2
tomatoes 6, :red
bacon 4
end

I'll admit it, this is not bad at all. Yet it annoys me to no end that I cannot just get those variables that I need from another context.

Thinking about there is a way to get variables, and that is the local_variables method, but you have to execute it within a specific context. There is also a method to pass around contexts, and that is binding. What we have to do is to get the binding of the block and to get the local variables within the context underlying the binding.

I tried to call the block and then get the binding of the block, but it didn't work. The block gets executed and the variables fall out of scope and become unavailable.

I had to get the block itself to return the binding. This can be done and it works, but the binding looks totally out of place..

shopping_list_for "BLT sandwiches for the picnic" do
sliced_bread = 3
lettuce = 2
tomatoes = 6, :red
bacon = 4

binding

end

Here it hit me that I could alias the word binding to something that would look good with end. What about the end ? I know it's tacky, but in its own tacky way it works and sounds credible:

shopping_list_for "BLT sandwiches for the picnic" do
sliced_bread = 3
lettuce = 2
tomatoes = 6, :red
bacon = 4

the end

This is the code that allows the DSL to work and to print out the shopping list:

def report recipe, ingredients
    puts "to make #{recipe} you should buy:"
    ingredients.each_pair do
        |ingredient,description|
        puts " * #{Array(description).join ' '} #{ingredient}"
    end
    puts
end

def shopping_list recipe
    shopping_binding = yield
    ingredients = {}
    eval("local_variables" , shopping_binding).
    each do |var|
        ingredients[var] = eval "#{var}" , shopping_binding
    end
    report recipe, ingredients
end

alias the binding

shopping_list "english breakfast" do
    tomatoes = 2, :green
    sausages = 3
    eggs = 2, :big
    bacon = 4
the end

shopping_list "banana milkshake" do
milk = 1
bananas = 2
the end

When you run it you get:

to make english breakfast you should buy:
* 2 green tomatoes
* 3 sausages
* 4 bacon
* 2 big eggs

to make banana milkshake you should buy:
* 2 bananas
* 1 milk

Pandora Music Genome

2006-04-26T22:57:00.000+02:00

Wow! That's all I can say, make sure you check this out: Pandora

It models what you like in music and makes very very sensible suggestions.

For example I like mellow rock with female vocal-centric aesthetics in minor key tonalities! Now I know what to answer when I am asked what music I like!

This Pandora thing is scary scary..

Ruby for Javists Presentation

2006-04-26T10:59:00.000+02:00

I am scheduled to give a 40mins presentation on Ruby to a group of javists (both standard edition and enterprise guys :-)

Do you have any advice on how to present it and what to show them?

I am not going to do the Ruby is Better than Java number, since that would feel offensive, but I would like to make them want to have a taste of ruby... I would like them to leave with a desire to explore new things.

Any advice is well appreciated!

Software Superheroes

2006-04-14T00:30:00.000+02:00

If there is one great thing about developing software is that software is probably one of the very few professions out there where you can be an awe inspiring Superhero.

Imagine if you were digging holes, moving rocks or filling in papers. How much difference would your skill make? You could perform maybe twice, three times better than an average worker. That's wholesome and fine, but how does it compare to superheroic feats such as flipping cars, vaporising enemies and flying at mach3?

Well, in software you can be that kind of superhero. Every improvement that you make, every skill that you learn, allows you to write better software and to handle greater complexity. If you can handle complexity you can build intellectual augmentations that are like a small army of cybernetic agents working for you. You harness the power of your skill and your agents, you simplify and organize and you move towards even greater levels of complexity.. that you can handle using abstractions. Your relative effectiveness is moving along an exponential curve by leveraging the previous software layers.

If you are a hotshot ruby programmer with a mastery of metaprogramming and you do dynamic programming con gusto, then you can take on a small IT department. Compared to a dozen of mediocre ASP programmers that copy and paste queries inside html code you are like a small determined hitech army. They won't even have the time to react. You are too fast for them. You do things they don't even comprehend. Sometimes they don't even understand that you are doing anything at all!

It's fun to be a superhero in the software world

(image by Chip Kidd)

Lisp, the 'Why' way

2006-04-13T02:30:00.000+02:00

I can't believe I found this. This is a comic book guide to lisp in a whyesque style. Great way to get started.

CodeSushi: Covering the Italian Scene

2006-04-12T13:34:00.000+02:00

Staring from today my CodeSushi blog is going to cover specifically the italian scene and it is switching to italian.

Using CodeSushi as a platform and meeting point I am going to push directly the italian software development scene and see what comes up from there.

The Liquid Development blog will continue as usual.

And remember.. Code Sushi, not Spaghetti Code ;-)

Software Management as Development of a Business Abstraction

2006-04-11T21:15:00.000+02:00

A very pretty piece from Joel - or how you know when management is failing badly.

It is too often the case that developers -and employees in general- have to pay with extra working hours for management failures..

Concrete Patterns Example

2006-04-10T12:21:00.000+02:00

I dug out an old link to some concrete examples of Patterns.
Considering how hard it can be to explain some of the esoteric development stuff, this can be an inspiration for us all.

The Book is Out (?!)

2006-04-08T02:33:00.000+02:00

What can I say?

I think that Kumo has got far too much time on his hands!

Thanks Kumo, much appreciated :-)

Let's say it's a late April Fool..

Upcoming Development Events in Italy

2006-04-07T13:35:00.000+02:00

Italy has never been very active on the international development scene. Let's see if we can turn this around :-)

Just a few links that make me proud:

Style and Stanzas

2006-04-07T01:07:00.000+02:00

The same piece of code can be written in a thousand ways, and every way has different tradeoffs in terms or readibility, expressiveness, debuggability, verbosity, etc..

Jean-Charles Carelli recently asked on the rubytalk mailing list how to improve on the following style from the pickaxe book:

# 1 Book example
songs.append(Song.new(title, name, mins.to_i * 60 + secs.to_i))

# 2 Alternate version.
duration = mins.to_i * 60 + secs.to_i
songs.append(Song.new(title, name, duration))

I like a multi-line nested format, that I call Stanza - you know, like in poetry.

It looks like the following:

songs.append Song.new(
                   title,
                   name,
                   duration = ( mins.to_i * 60 + secs.to_i )
             )

It clearly shows you what you are appending as a chunk of code on the right. the 'duration =' idiom makes the intent explicit. I use brackets to nest conceptual entities (Song, duration), so that they stand out as visually striking, which is useful if you are doing some Gestalt Code Reading.

Sometimes, using metaprogramming I also get rid of the explicit new by wrapping up object instantiation with a Song(..) method on the top level. I use this Implicit Constructor because I don't want to be concerned with object creation in my code, just with the meaning of the entities that I am manipulating.

songs.append Song(
               title,
               name,
               duration = ( mins.to_i * 60 + secs.to_i )
             )

Perceptual Stances: Start Small

2006-04-05T11:22:00.000+02:00

I am interested in the tricks and hacks that we can use to somehow 'mechanically' steer and control our perception.

Presentation Formats are one way to do this, forcing you to express some content within an artificially imposed presentation frame.  The unusual 'shape' of the container can force you to reshape the content and discover some previously hidden properties.

Perceptual Stances (Thinking Formats?) do the same thing by forcing us to focus only on certain aspects of our subject matter.  Business Pundit wrote an interesting post that points out how you can unleash your creativity and get started by focusing on small thing rather than on grand theories and stereotypical thinking.

It strikes me that some of the examples he uses seem almost related to techniques I found in Drawing On The Right Side of Your Brain: Drawing Negative Spaces and Semantic-Neutral Drawing. These are not the names the author would have used, but if you are interested I can expand on them.

Presentation Formats: Lightning Talks

2006-04-05T02:42:00.000+02:00

Lighnting talks are quick nuggets of information, usually delivered within 5 minutes. I like formats, because they force you to take unusual approaches and points of view. I like space and time constraints, because they force you to be synthetic and expressive.

Have a look at the Lightning Talk format:
* Giving Lightning Talks
* Lightning Talks

Gestalt Code Reading

2006-04-04T01:05:00.000+02:00

This is a follow up from some considerations in the comment section of the previous post.

If you have been writing code for some time I am sure that from time to time you also experience the weird psycognostic power of gestalt-reading code. When I say gestalt-reading I mean that feeling of absorbing the main points and relationships of code by simply giving it a quick glance, just flicking through several pages of code.

You don't know exactly what you have read, but you somehow have an overall impression of what the code does and how the different abstractions are related.

What do you think this is due to?

I believe it is a mix of code indentation, code conventions, general domain culture and the ability of visualizing code on the fly via iconic images. Next time you use your superpowers pay attention to what is happening within your perception process. If your perceptual habits are even a little bit similar to mine, you will probably notice that when you read code you see little boxes and arrows, popping into existence on the backstage of your counscius awareness, connecting together according to well-known patterns.

The knowledge of this process may turn out to be quite important when deciding what code should look like. Proper alignment of braces and indentations.. the feeling of un-closure that I sometimes feel when looking at python code (it feels more like a flow than like legos). My mind looks for visual patterns and simplifies them into icons and boxes, probably also relying on subtler cues and unconscious processes to build meaning.

It's interesting to see what information we can get from this kind of code reading. I can get the main conceptual entities because I can visually spot classes and attributes. I can get the broader relationships too, probably because of a good rational choice of class names, sometimes due to the naming of attributes, occasionally by seeing how some object instances are built and attached to each other. I rarely get the algorithms at a first glance, although I seem to remember that I used to be able to, before doing OOP.. but I am not sure if that really was the case, in the same way as I can do it now with objects. One thing is for sure: much of the metaprogramming cleverness is lost.

However, if the metaprogramming could be kept simple and regular and visually striking, then it could be absorbed much more easily. Think about ActiveRecord. Maybe it doesn't matter so much how we say something, as long as we can make it visually recognisable and compelling, so that it promotes easy visual parsing.

I was almost giving all sorts of non-visual code reading now, and I was forgetting test code. Test code is a conspicuous exception to what I have just said about visual parsing. If a project has tests I prefer to read the tests rather than the project code. Tests are better at capturing the intent of the code and the way to interact with it. They also clearly capture the dynamics of instances, providing not only a compositional/structural view of code, but also the modes of interaction with the code. However tests must be read and cannot be simply absobed using gestalt-reading. Maybe that's because they tend to specify behaviour rather than structure...

Minimal Descriptions and Metaprogramming

2006-04-03T01:24:00.000+02:00

My fellow socialite Pilu has opened a blog, Gurage, where he provides an introductive examples to Rails. He uses a simple inheritance example describing a Guitarist and a Singer as being two subclasses of Artist.

While reading his code, that describes a Struct-like class (more an holder of attributes than an holder of behaviours) I thought back to a discussion that we had at the Ruby Social Club meeting about metaprogramming tricks. My point was that through metaprogramming you can redefine the language in such a way that you can also provide stereotypical descriptions for classes and methods, so that you don't have to explicitly describe initializer, accessors, and so on.

For example, this code written by Pilu

class Artist
  attr_reader :name
  def initialize(name)
    @name = name
  end
end

could easily become something like:

Artist = Struct.new :name

This second form is no doubt more compact, but is it better?

Forget the fact that the full class definition already provides the 'space' to add in new methods and attributes. Assume that the code is done and you are simply reading it. What is better? and why?

Something tells me that I would like the more terse and compact form, but somehow I still find that the first form has got something that the compact form lacks. I just can't put my finger on it.

Following on from Pilu's example I would like to have a compact formalism that allows me to say something like:

Artist defined by name

Guitarist is an Artist also defined by guitar
Singer is an Artist also defined by microphone

Using metaprogramming is not too hard to generate this kind of Minimal Descriptions, although they would probably look like this:

Artist = defined_by :name

Guitarist = Artist.also_defined_by :guitar
Singer = Artist.also_defined_by :microphone

I will leave the metaprogramming as an exercise for the reader :-D

The 'defined_by' is just wrapping a call to ' Struct.new', probably also adding a few extras such as a comparison operator and a prettier to_s method. The 'also_defined_by' is a method that has been injected into the Class class. It creates a new anonymous subclass, adding a few extra accessors and also overriding the initializer by adding some extra parameters.

We have seen how this is technically feasible, I just wonder if this is what we want.

The standard way of doing things shows us explicitly that we are dealing with a class. The 'class' and the 'end' words and the indentation highlight clearly a chunk of code and identifies it as being a class, an important concept within the narrative of our system.

The Minimal Description approach tries to hide away the whole concept of class. It simply cares about concepts and meaning and it abstracts away a big body of knowledge. The body of knowledge that is abstracted away is that we are defining classes and that these classes are related by inheritance. It is also assuming that we know that if something is defined by a certain characteristic, then this characteristic will have to be used when creating an instance of that concept.

What do you think? Is this a rightful use of metaprogramming and of Shaping code After Language, or is it a blatant abuse of metaprogramming power?

Apology of Excel and Excelagility Part III - Streaming Objects from/to Excel

2006-03-29T23:51:00.000+02:00

I hope that some of you are actually reading these posts on Excel.

I know, it's not a very sexy topic, but I would like to convince you that in some contexts, under specific conditions, it can be a real kick-ass environment for truly agile development.

I agree, VBA is now pretty old and it has several limitations.. but less than you would normally think. In the course of the future posts you might find a few interesting and generally useful tricks as I show you how to get around the lack of implementation inheritance and even do some degree of reflection and functional-style programming.

Excelagility

- or -

How to Shape Excel with VBA into a Legible Expressive Agile Platform

V. 0.0.4

Writing Objects to Excel

We have seen how to write out objects to the Immediate Window, but what about writing them to the Excel sheets? After all we set out to work and to be productive within the Excel environment, didn't we?

All you need to do is to extend your class with a 'toExcel' method.

Sub toExcel(startcell As Range)

startcell.Offset(0,0) = Me.Name

startcell.Offset(0,1) = Me.Surname

startcell.Offset(0,2) = Me.DateOfBirth

End Sub

That's it!

Dim a_person As Person

Set a_person = Person("John","Smith",#23/11/1980#)

a_person.toExcel [B3]

a_person.toExcel Workbooks("Book1.xls"). _

Worksheets("Sheet2"). _

Range("D10")

a_person.toExcel Workbooks("Book1.xls"). _

Worksheets("Sheet2"). _

Range("my named cell")

This code will allow you to write out your person to Excel, horizontally. If you want to write it vertically, then you would have had to swap the row and column numbers in the call to the 'Offset' function within the 'toExcel' method. You could parametrize the method with an optional parameter to choose the direction of the print out.

Reading Objects from Excel

Now that we are able to write out Person objects to excel we would also like to allow our users to edit the excel sheet before loading this data back into VBA.

We have seen how to build a Person programmatically, using a Noun function. We will now see how to assemble a Person object from data found on an Excel sheet.

First of all we need a way to create a new Person from scratch, without setting any of its attributes. Once we have a Person object we can then call a 'fromExcel' method to initialise its attributes.

This could be written as:

Dim a_person As Person

Set a_person = New Person

a_person.fromExcel [b4]

However, as we are quite lazy, we would prefer to write something like:

Dim a_person As Person

Set a_person = Person_fromExcel [b4]

The command 'Person_fromExcel' can be defined as a new Noun that assembles new Person objects from a cell reference.

Module Nouns

Function Person_fromExcel( _

startcell As Range _

) As Person

Set Person = New Person

Person.fromExcel startcell

End Function

End Module

All that is left to do is to define the 'fromExcel' method.

Sub fromExcel(startcell As Range)

Me.Name = startcell.Offset(0,0)

Me.Surname = startcell.Offset(0,1)

Me.DateOfBirth = startcell.Offset(0,2)

End Sub

Unsurprisingly, we can see that it is the almost exact converse of the 'toExcel' method.

Being able to read and write objects from and to excel is invaluable when you are trying to reason on the objects of your problem and you want to be able to edit them while the program is running.

Ruby Social Club - 1st April Milan Meeting

2006-03-28T01:14:00.000+02:00

The Ruby Social Club is getting up to speed and spreading fast. After the first two meetings in Rome we are going to meet up in Milan on the evening of saturday the first of April.

In the course of the first two meetings I have met very nice easy going people, and very competent brilliant developers too. It's hard to find the right alchemy that allows you to talk offhandedly with newly met people about metaprogramming and semiotics, while drinking good wine and picking at arrosticinos.

The avenue has not been defined yet, but you can keep up to date via our italian Ruby-It wiki page.

If you fancy catching up with us there, get in touch with us and we will make sure there is enough wine and food for you too :-)

The Art of Shaping

2006-03-28T01:09:00.000+02:00

Shaping Code After Language is in the air.. and I believe it is the way to go. In these two posts I am trying to capture the spirit of Shal and put it down on paper..

The Way of Meta

2006-03-28T01:08:00.000+02:00

The first four and half installments of an exploration of Ruby Metaprogramming

Part IV and half :-)

Evolving Intent

2006-03-28T01:06:00.000+02:00

My explorations of Intent and how it develops from Test Driven Design

Excelagility - Shaping VBA into an Agile Platform

2006-03-28T01:02:00.000+02:00

The first two draft installments of my attempt at showing the power of Shaping Code After Language and redeeming Excel and VBA as an agile platform..

Updated Table of Content

2006-03-08T22:22:00.000+01:00

I have updated the Liquid Development Table of Contents with the latest posts..

Excelagility - Part II - Printing out objects with external polymorphism

2006-03-08T20:19:00.000+01:00

Where we explore how to get rid of some of the verbose bureaucracy of VBA and how to create uniformity using 'Verbs' and external polymorphism..

Excelagility

- or -

How to Shape Excel with VBA into a Legible Expressive Agile Platform

V. 0.0.2

Printing Out Objects

Now we have objects, but it's not easy to print them out to screen, for example for debugging purposes.

We can do this by providing each class which is of interest to us with a method that converts it to string: a 'toString' method.

Dim a_person As Person

Set a_person = Person("John","Smith",#23/11/1980#)

Debug.Print a_person.toString

Let's add such a method to the 'Person' class:

Function toString() As String

toString = "Person(" & _

Me.Name & ", " & _

Me.Surname & ", " & _

Me.DateOfBirth & ") "

End Function

Now you can easily print out a Person object to the Immediate Window.

However, having to write 'Debug.Print' and 'toString' is quite verbose and we can devise a way to make this more readable.

Sub puts(an_entity)

Debug.Print strize(an_entity)

End Sub

The new 'puts' command substitutes the lengthy 'Debug.Print' command and it also forces the argument passed to it to be converted to a string. The actual conversion is performed by the 'strize' (short for string-ize) function.

The code for the 'strize' function employs a technique that I call 'external polymorphism' to handle entities of any type and not only Objects.

Function strize(an_entity) As String

If IsObject(an_entity) Then

strize = an_entity.toString

Else

strize = CStr(an_entity)

End If

End Function

This code now allows you to write much more expressive statements:

Dim a_person As Person

Set a_person = Person("John","Smith",#23/11/1980#)

puts a_person

puts a_person.DateOfBirth

puts a_person.Name

The 'puts' command, however, is not as robust as we would like it to be. If you pass it an object that does not implement the 'toString' method, then it will fail without providing much of an explanation. We can make it more robust by adding some simple error handling:

Function strize(an_entity) As String

On Error Goto cannot_convert_to_string

If IsObject(an_entity) Then

strize = an_entity.toString

Else

strize = CStr(an_entity)

End If

Exit Function

cannot_convert_to_string:

strize = TypeName(an_entity)

End Function

If the entity passed cannot be converted to string, then we recover by returning simply the type name of the entity. Alternatively we may want it to return an error message, using the 'MsgBox' command.

Excelagility - Part I

2006-03-07T00:44:00.000+01:00

This is the first installment o a serie on how to shape VBA and Excel into a useful agile tool. I know, it's difficult to believe, but it can be done!

How can I convince you of the usefulness of this well known unholy duo? :-)

For the time being, let it suffice to say that one of the main tenets of liquid development is not just to work with users, but to get users to write code with us.. and one of the best way to get them to write code, to directly express their intent, is to do it in such a way that they don't even realize they are coding.

In the course of these installments I will try to prove this point and to show you at the same time how you can Shape Language to your needs, even if it is VBA.

Excelagility

- or -

How to Shape Excel with VBA into a Legible Expressive Agile Platform

V. 0.0.2

Introduction

This booklet will show you how to be agile and effective using Excel with VBA.

Defining Classes

When you design a class for an excel addin, keep the class private, unless you need to use it from another module (more on this later).

Class Person

Public Name As String

Public Surname As String

Public DateOfBirth As Date

End Class

Use public properties, as in:

Public Name as String

Public properties make the code much simpler to read and can always be privatised later, should the need arise.

Assembling Objects with Nouns

Once a class has been defined, objects are easy to create:

Dim a_person As Person

Set a_person = New Person

a_person.Name = "John"

a_person.Surname = "Smith"

a_person.DateOfBirth = #11/23/1980#

Although objects in VBA can be created with a simple 'New' statement, we prefer to use a somewhat more articulate method. Since we want to have exact control on how an object gets created, initialised and built, we introduce an intermediate layer that takes care of assembling objects for us.

This layer should allow you to create and initialise objects in a much more readable way:

Dim a_person As Person

Set a_person = Person("John","Smith",#11/23/1980#)

We name this layer the Nouns layer, and we represent it as a Nouns module present in every excel add-in.

Module Nouns

Function Person( _

a_name As String, _

a_surname As String, _

a_date_of_birth As Date _

) As Person

Dim a_new_person As Person

Set a_new_person = New Person

a_new_person.Name = a_name

a_new_person.Surname = a_surname

a_new_person.DateOfBirth = a_date_of_birth

Set Person = a_new_person

End Function

End Module

The Way of Meta - Part III

2006-02-21T23:42:00.000+01:00

The Way of Meta

V. 0.0.3

Writing Method Generators

I am going to write a simple example that illustrates how you can create a method generator: a construct used within a class definition as a shortcut to generate richer method semantics, in the same way that attr_accessor generates enrich class behaviour by adding new methods.

This example concerns the development of a 'synonym' generator. A synonym is similar to an alias because it provides different calls to achieve the same result. It is different from an alias in that an alias generates a copy of a method, rather than a different name to call the same method.

If an aliased method gets overridden, its aliases will keep calling the old code. Conversely, a synonym of a method is a simple light code layer that keeps calling a certain method name. If the aliased method gets overwritten, then all its synonyms will start calling the new version of the method.

Let's start from our intent; let's visualise how we would like to use synonyms.

class Person

def say

"hi"

end

def walk

"one step"

end

synonym :say => [ :talk , :discuss , :greet ],

:walk => [ :stride, :run, :jump ]

end

Here we are declaring that both the method 'say' and the method 'walk' have several synonyms.

We also expect the following statements to be true

p1 = Person.new

p p1.talk == "hi"

p p1.discuss == "hi"

p p1.greet == "hi"

p p1.stride == "one step"

p p1.run == "one step"

p p1.jump == "one step"

They should become false when we override the old methods:

class Person

def say

"yo"

end

p p1.say == "yo"

p p1.talk == "yo"

p p1.discuss == "yo"

p p1.greet == "yo"

Enough talking, we have all the intent we need for a first stab at the problem. Let's dive straight into the code.

First of all we need a convenient way to process the arguments passed to the 'synonym' generator.

Consider how we will need to elaborate the following hash:

:say => [ :talk, :discuss, :greet ],

:walk => [ :stride , :run , :jump ]

This is just a convenient idiom that we use to express the following relationships:

[

[ :say, :talk ],

[ :say, :discuss],

[ :say, :greet ],

[ :walk, :stride ],

[ :walk, :run ],

[ :walk, :jump ]

]

Let's write some code that can take us from the first compact format to the second explicit representation. We will call the relationships 'associations' and we will provide a method that allows us to iterate over a hash one association at a time.

# expands a => [b1,b2,b3] associations to [a,b1], [a,b2], [a,b3], etc..

class Hash

def each_association &block

self .each_pair do | assoc_key, assoc_targets|

assoc_targets.to_a.each do |assoc_target|

block.call assoc_key, assoc_target

end

Now that we have a way to visit our associations, we will generate a new synonym method for each association:

class Module

# associations: ( old_name => [new names] )*

def synonym associations

associations.each_association do

| original_name_sym, new_name_sym|

define_method( new_name_sym){ |* args|

self .send original_name_sym, *args

}

end

For each association specified in the synonym generator we inject a new method in our class. The new method has the name specified on the right hand side of the association, and all it does is to invoke the original method of the class.

The synonym generator has been defined within the Module class, so that it becomes automatically available within the context of the classes 'Module' and 'Class'.

We can now use the generator even to expand existing classes with new developer friendly names.

Here we tweak the Array class:

Array.class_eval do

synonym :size => [ :count, :n_elements ]

end

p [1, 2,3 ].count == 3

p [1, 2,3 ].n_elements == 3

And here we provide a way to talk to a Person, rather than giving him orders!

class Person

def calculate( a,op,b)

a.send op, b

end

p (p1.calculate 3, :+, 2) == 5

class Person

synonym :calculate => :how_much ?

end

p (p1.how_much? 3, :+, 2) == 5

It is worth pointing out a small syntactic trick that we used to handle both cases of single ( :calculate => :how_much ?) and multiple synonyms (:size => [ :count , :n_elements ]).

We get the right hand side of the hash element and we apply 'to_a' to it, turning it into an array.

…

assoc_targets.to_a.each do |assoc_target|

…

end

…

If the element is not an array, it gets turned into one. If it is already an array, it is left unchanged. Whatever the case, we are left with a simple array to operate on in the end.

The Way of Meta - Part II

2006-02-19T20:38:00.000+01:00

The Way of Meta

V. 0.0.2

Exploring Ruby Metaprogramming Capabilities

Getting our Feet Wet

Tired of all this talk? Then it is time to dip our feet in the deep waters of rubesque metaprogramming. We are going to start our journey exploring the metaprogramming features that are illustrated in the pragmatic programmers' PickAxe book, while at the same time we will go through the less known libraries present in the ruby distribution. At the same time we will ask for some help to the wonderfully brief and clear 'Seeing Metaclasses Clearly' by Why the Lucky Stiff.

Out-of-the-Box Metaprogramming Mechanisms

Ruby provides several straight out of the box metaprogramming mechanisms with its core standard libraries. Although using these mechanisms can take you very quickly to unmanageable levels of complexity it is worth looking at them to have a feeling of what is possible. Later on we will encapsulate these mechanisms within our own metaprogramming protocol.

Loading Code

In many languages, the mechanism that allows your source code to refer to a library or to another piece of code is handled by the language in an opaque way. Not so in Ruby.

When using Ruby you are in charge of the code loading.

The 'load' command loads some ruby code, right where you are calling it.

load "myfile.rb"

The 'require' command adds a little check that prevents the loading of the same file twice from different points in the code.

require "filename"

Load and require are not special commands for the compiler, they are dynamically executed and can be embedded within blocks, control statements, etc. The name of the file that they load can also be constructed dynamically.

The load construct in particular allows you to reload code definitions any number of times if they get changed inside the file. It's now easy to see how your code could generate code files, maybe using a templating mechanism, and then load them back in the runtime.

Principles of Ruby Metaprogramming I: Source Code Files are Dynamically Loaded, not Statically Included

There are two environment variables that can turn out to be helpful when dealing with dynamic source code loading.

$LOAD_PATH is an array of directories that are searched for source code by 'load' and 'require'.

$LOADED_FEATURES is an array containing the filenames of the files that have already been loaded.

The Way of Meta - Part I

2006-02-19T01:43:00.000+01:00

I might have mentioned it, but I am planning to write a book on Liquid Development. A big part of Liquid Development is about shaping code and knowledge after our own linguistic structures. Metaprogramming becomes a technique instrumental to shape and bend a language to your wishes.

Today I am going to post the first part of a rough draft on metaprogramming that I am putting together for the book.

The Way of Meta

V. 0.0.1

Exploring Metaprogramming in Ruby

I have been a fan of metaprogramming techniques for a long time, but I have been able to fully indulge into this deplorable habit only after having taken up programming in Ruby.

What's the deal with this metaprogramming thing? There are lots of tutorials and introduction out there on the web, so I am not going to go into the historical details here, but I will give you my own personal definition of metaprogramming.

Metaprogramming as Deep Magick

Metaprogramming has meant different things at different times, but at any particular time what metaprogramming seems to mean, is the ability of somehow getting into the inner working of the language that you are using, so that you can produce what is sometimes referred to as "deep magick". It does look and feel like magick, because when you go 'meta' with programming, you are moving outside the realm of everyday modelling, to step into the world that defines the very rules of ordinary programming.

Many of the concepts of object orientation feel like metaprogramming the first time you see them. I clearly remember the sharp feeling of power and magick the first time I saw C++ operator overloading in action as a young man. It felt like I could plunge into the core of the language, inside the very definition of the metaphysics of programming and change the way I could represent the world, on a whole new level.

Metaprogramming considered Harmful

The term metaprogramming covers lots of ground, and it represents more a philosophical focus than a specific set of techniques. The capabilities of Metaprogramming can be potentially so powerful and far reaching that can also be completely devastating.

If you are able to tweak the underlying layer on top of which you build your representations, you can change the semantics of all the relationships that you have built between your 'ordinary' conceptual objects. This can add new features (aspects) to your program, or it can simply make it wrong, breaking its intent, or it can make it totally unworkable and inconsistent. It could also cause unforeseen interferences between your meta-code and the program, between two different sets of code, or within the libraries your code relies on.

Metaprogramming on the Leash

So, is Metaprogramming a good or a bad thing? I would say that it is good if used parsimoniously, when no other conventional technique can yield the same elegance and results. It should also be used when it can help removing duplication in your code, while adding clarity to it.

However it should be used in a very controlled way. Metaprogramming almost always involve some degree of run-time creation and customisation of code that gets injected into the realtime machinery of your program. The code generated by your 'meta-code' is usually invisible to the debugger and you will not have any chance to inspect it and debug it from the inside. I leave it to you to decide how dangerous and error prone this can be.

All your metaprogramming code, once verified that it is working, should be abstracted away into a set of more rigid mechanisms, with a precise name and meaning that can be put under test and documented. All these mechanisms should also support ways to output the code they generate and to probe the realtime looking for potential lexical conflicts.

A simple example of 'controlled metaprogramming' is the attr_accessor mechanism in Ruby. When inside a class you declare a symbol as being an attr_accessor with

attr_accessor :my_symbol

you are using a metaprogramming technique that generates a @my_symbol attribute, and both a getter and setter method for that attribute.

Metaprogramming Protocols

Playing with the laws of reality can become a very messy thing very quickly; even more so when you are not the only one doing it.

What happens if you override the method_missing mechanism of the Object class to implement your flavour of metaprogramming, only to discover that a library you were using was leveraging on the very same technique and you just interfered with it?

You will soon start applying your meta-code as a sequence of patches that assume the presence or the absence of other libraries and become rigidly dependent on which libraries are present and ion their loading order.

When you start playing with metaprogramming you will soon come to realise that you don't even need third party code to mess things up. You will probably perfectly manage to bring havoc on yourself within a few visits to the metaphysics underlying the Kernel and Object classes.

A Metaprogramming protocol could be the only way to get things in order at this point. A metaprogramming protocol offers an orderly way to access to some of the more dangerous and interference-prone mechanisms of the meta-layer. Rather than acting directly on the meta-mechanisms, you ask a meta-framework to do it for you, while specifying exactly what you need. The meta-framework will take care of registering your request and to handle the interference between similar requests coming from different libraries. The meta-framework will usually act as a kind of multi-dispatching system with a call-back mechanism on its callers.

Digging into Ruby Symbols - O'Reilly Ruby

2006-02-13T00:54:00.000+01:00

Another very simple intro to Ruby metaprogramming

Haskell

2006-02-12T02:26:00.000+01:00

I really should spend some time and learn the language. I did it at Uni but I didn't dig it at the time and I haven't really done much with it. As I get older and I start appreciating the functional flavour I should have a go at it.

Ruby Social Club

2006-02-11T00:37:00.000+01:00

Roberta and I have organised a nice evening amongst Ruby programmers in the Rome area on Thursday night. It has been a good evening, spent at a pub in the centre of Rome drinking lager, eating nice food and talking about our experiences. I will write more about it, but for the time being I just want to thank everybody that turned up. It was good to meet up with so many good people sharing my very same interests.

Here are a couple of web pages both in italian and english, describing what we Ruby socialites are up to.

Beyond mainstream object-oriented programming

2006-02-11T00:28:00.000+01:00

Thanks to Gabriele Renzi for pointing this out on his blog.

This is a nice article on interesting thoughts around and beyond OOP.

Ruby Metaprogramming

2006-02-09T02:25:00.000+01:00

This is an excellent OSCON presentation written by Vanderburg: www.vanderburg.org/Spea...

After reading it, I have started publishing some draft excerpts on Ruby Metaprogramming from the 'Liquid Development' book that I am writing:

The Way of Meta - Part I
The Way of Meta - Part II
The Way of Meta - Part III

Distilling Intent from Descriptions

2006-02-05T05:08:00.000+01:00

This is a follow up to my previous posts on the use of intents to describe the game of maru batsu (well, maru-batsu sounds much cooler than tic-tac-toe :-)

Every now and again I practice this small maru-batsu kata to see how my perception of things changes in time as I learn new ways of approching the encoding of intent.

Something that I notice by reading my early posts is that, while the code is not bad, I tend to get too technical too early. I know I shouldn't abstract too early. I know I shouldn't create abstractions unless my intents prove that I need them (this process of spawning abstractions is described in Shape Code After Language).

Yet I always fall into the sin of over-abstraction. It's not a big deal; sometimes it's just a matter of abstracting a Player class, because I feel it's a natural element of the maru-batsu discourse. They taught us to make classes out of concepts, just in case we might need them.

More I practice this kata, more I realise that I can do with less and less. It feels pleasant to feel how much lighter the intents (and the code) become. The Player doesn't need to be a class. Most of the times it can simply be a symbol, and the way it is used can be made implicit by the context and illustrated by intents and stories.

Today I will practice the kata one more time, in an iterative way. Be patient, the code doesn't need to run as-it-is, as it is just a first exploratory attempt at designing intents.

This is a first rough natural language description of maru batsu:

maru batsu is played by two players on a 3x3 board
a player uses X marks, while the other uses O marks
the players take turns
a player, in his turn, can put his mark on the empty squares of the board
a player that aligns three of his symbols on the board (Horizontally, vertically or diagonally) on the board wins.
if nobody has won and no new moves are possible, then it's a draw.

Then I get each statement in turn and I try to make it a bit more formal. I will also put some comments of problems that I noticed only after the fact.

"maru batsu is played by two players on a 3x3 board"
expect marubatsu.players.size == 2
expect marubatsu.board.width == marubatsu.board.height == 3

Why players.size when I could have n_of_players ? Why did I feel the need to make explicit the inner structure of marubatsu? This just creates just more coupling without any immediate additional benefit. An ethnographer would probably point out that I am giving implicit importance to the concept of Player. I am probably reifying players because they belong to my everyday universe of discourse. The same line of reasoning applies to board.width. These declarations of structure are actively implying a universe of games made out of boards and players. While this might be a useful abstraction, it is an abstraction that I did not produce consciously. It just seemed to be the 'natural' abstraction. I erroneously perceived it as being 'the-way-the-real-world-is'.

"a player uses X marks, while the other uses O marks"
expect (marubatsu.symbol_of :player_A) == :X
expect (marubatsu.symbol_of :player_B) == :O

Here I resisted using strings to represent X and O. They are symbols, they stand for things, for marks on the board. They represent universal concepts. They relate to the fly-weight structural pattern.

Yet I used 'symbol_of :player_A' rather than ' symbol_of_player_A'. Again, why did I feel the need to abstract this, as if I could want to play maru batsu with a variable number of players? It's so hard to forget your symbolic perceptual stance and see things as they are. I wonder if reading again Drawing on the Right Side of the Brain could help me to get back to a more immediate reality.

"the players take turns"
    marubatsu.turn?.should_be :player_A
    marubatsu.next_turn!
    marubatsu.turn?.should_be :player_B
    marubatsu.next_turn!
    marubatsu.turn?.should_be :player_A

Again I implicitly assume a multitude of players. Why not 'is_turn_of_player_A?'

"a player, in his turn, can put his mark on the empty squares of the board"
    marubatsu.turn?.should_be :player_A
    dont_expect marubatsu.board.has_mark_at? row=2, col=1
    marubatsu.board.mark! row=2, col=1
    expect (marubatsu.board.mark_at? row=2, col=1) == :X

Besides the over-complex designs that I have already pointed out, I have managed to do a couple of nice moves here. I use the ' row=2' parameter passing notation to specify the meaning of the number passed. I also changed an initial 'marubatsu.board.mark_at?(row=2, col=1) ' to '(marubatsu.board.mark_at? row=2, col=1)'. There is no semantic difference between the two notations, but I prefer the second one as I like to visualize what is inside the brackets as a single entity on which I do an operation. In the former case the brackets were used to delimit a function parameters. I tend to prefer to think in terms of entities than in terms of flows of data between functions. This doesn't mean I don't like the functional style of programming.. mmh this is an ambiguous point I'll have to expand on in a future post on Stanzas and Dyamic Aggregates.

Take note of the fact that the sentence "a player, in his turn, can put his mark on the empty squares of the board" also implies that "a player, in his turn, can NOT put his mark on the NON empty squares of the board". I am going to state this intent as well.

"a player, in his turn, can NOT put his mark on the NON empty squares of the board"
marubatsu.turn?.should_be :player_A
expect marubatsu.board.has_mark_at? row=1, col=1

    expect_exception( :SquareUsedException ){
        marubatsu.board.mark! row=1, col=1
    }

To show that this intent holds, we state that we expect an exception in case we try to tick twice the same square of the maru batsu board. From a technical point of view, it's nice to be able to state explicitly what kind of exception I am expecting here. However, from a legibility point of view, something different might have been better. Something like "cannot do marubatsu.board.mark! ..., because :SquareUsed" might work even better!

"a player that aligns three of his symbols (Horizontally, vertically or diagonally) on the board wins."

    marubatsu.set_board [:X, :O,:O],
                        [:X, :-,:-],
                        [:X, :-,:-]

    expect marubatsu.winner?
    marubatsu.winner.should_be :player_A

    marubatsu.set_board [:O, :O,:O],
                        [:X, :-,:-],
                        [:X, :-,:-]

    expect marubatsu.winner?
    marubatsu.winner.should_be :player_B

    marubatsu.set_board [:X, :O,:O],
                        [:-, :X,:-],
                        [:-, :-,:X]

    expect marubatsu.winner?
    marubatsu.winner.should_be :player_A

It might have been better to split this intent into three different intents, each one specifying one way to win (horizontal, vertical, diagonal). Since I didn't want to have to play out a whole game to check winning conditions, I introduced a set_board verb that allows the injection of a board into the game. I wonder if this is really a good thing. From a TDD point of view it is a good thing since it introduces flexibility into the design, but this is not flexibility that is needed to describe the game play, so I am not so sure about it. I am not sure about a valid alternative either, so I'll keep it for the time being.

Another problem is that the examples are not exhaustive at all. I do not show the whole range of winning combinations, and the combinations that I show are not shown for all players. There should be 8 (3+3+2) winning combinations for each player, for a total of 16 combinations. In this simple game I could even enumerate all of them, but what about more complex games? How would you test moves in a game of chess?

I like the way I set up the board using arrays, and how I resisted making up Board and Cell objects. I don't like the fact that I tried to stay abstract using symbols and using :- to signify a blank cell. It would have been much clearer to use strings. Something like:

    marubatsu.set_board "XOO",
                        ".X.",
                        "..X"

or even something like

marubatsu.set_board <<-board

                            XOO
                            .X.
                            ..X

board

which would then have the burden to decode the multiline board string. While this may be too heavy for this simple case, this approach could also be used to introduce small DLS-like dialects inlined within the code.

As in a previous intent "a player that aligns three of his symbols (Horizontally, vertically or diagonally) on the board wins." also implies the following converse intent:

"there is no winner if three equal symbols are not aligned (Horizontally, vertically or diagonally) on the board"

    marubatsu.set_board [:-, :-,:-],
                        [:-, :-,:-],
                        [:X, :-,:-]

    dont_expect marubatsu.winner?

    marubatsu.set_board [:-, :X,:-],
                        [:-, :O,:-],
                        [:X, :O,:X]

    dont_expect marubatsu.winner?

but how can you 'prove' that there is no winner? how can you prove that there is a winner without enumerating all cases? Do I need to prove things or do I simply need to enumerate some examples useful to elaborate working code?

"if nobody has won and no new moves are possible, then it's a draw."

    marubatsu.set_board [:X, :O,:O],
                        [:O, :X,:X],
                        [:X, :X,:O]

    dont_expect marubatsu.winner?
    expect marubatsu.draw?

again, should I enumerate all possible draws?

should I also state all the following?

"if someone has won then it's not a draw."

    marubatsu.set_board [:O, :O, :O],
                        [:X, :-, :-],
                        [:X, :-, :-]

    expect marubatsu.winner?
    dont_expect marubatsu.draw?

"if nobody has won but new moves are possible, then it's not a draw."

    marubatsu.set_board [:X, :O, :O],
                        [:O, :X, :X],
                        [:X, :-, :O]

    dont_expect marubatsu.winner?
    dont_expect marubatsu.draw?

.c( whytheluckystiff )o. -- Seeing Metaclasses Clearly

2006-01-27T02:05:00.000+01:00

This is a useful tutorial on metaclasses by Why.

I wanted to do it all alone, but I will try to resist and see what is already available for me to build on.

Online Community Building Tools

2006-01-23T22:42:00.000+01:00

A friend recently called me up asking my help to enhance the ties of some activist groups he is touch with, by using the web.

I have been reading a bit about the web2.0, I had a quick brush with Ning and I mused on philosophical issues.

Now, it is the right time to act.

I am pretty certain that what I want to do is to not start some kind of website project from scratch.

The group already has a small website, acting as a web frontend for the organization, but I would rather go for existing services or a mush-up rather then trying to run the infrastructure on our own.The other point is that, while I am very willing to spend time to create new stuff and put ideas together, I am not willing to put much effort into the maintenance.

I also believe this is a chore that the community itself should take care of, learning how to live their own spaces and take care of them.I can see that on the web there are plenty of web2.0 apps, but what I see missing is some kind of glue to put together what I need into a single mushup.

The lack of a single sign-on is particularly critical.

We could go around this, by gathering user subscription requests through the main site and then automate subscriptions to all the different sites of the mush-up, making sure the usernames and passwords are unique.

However this is both labour intensive and it raises some doubts from a privacy point of view. What I am doing now is to look for a all-in-one community container.

Something that provides single sign on to a number of basic services, which allows html customization and enhancements, and that allows easy administration of the system.

These are some promising links that I have found:

Software Roadmap

2006-01-20T21:08:00.000+01:00

I have started a number of small projects, both to explore ruby's capabilities and to play with some concepts that I found hard to express in other languages. These projects are still in their infancy, so I haven't put them on rubyforge yet, but I plan to work on releasing them soon.

The projects are:

Intent: this one has been released. It provides BDD-like statements on code, as an alternative to regular testing.
Proze: it translates code - and intents in particular - to readable text. It has been embedded in Intent.
Agave: a small set of metaprogramming utilities
Jazzgarden: 'smart' operations on objects - spreading commands over collections, taking 'slices' from object collections
SmartStores: implicit mapping of directory and file structures to object aggregates. mapping of file types to classes.
Clay: a nooclay substratum able to provide lots of shorthands and syntactic sugar, including object instantiation without the new method.
Avocado: support for Concepts and Relationships representations
Highrise: a small financial framework; yield curves, NPV, etc..
Gammaray: an easy access to an opengl subset to represent graph relationships in 3d
Marubatsu: an Intent-first implementation of tic-tac-toe, to be used as an Intent showcase
Trickle: an Avocado and Gammaray based application that helps you design brainstorming sessions on a number of topics: plots, characters, ideas, etc..

I will show a couple of prozed intents from these projects. If any of you is interested in any of them, let me know and I might focus my efforts on what becomes more popular and I will release it on rubyforge.

Agave

a small set of metaprogramming utilities

intent of "Generating text from a line of text and variations"

    "Dear <title> <person>"
        substitute
            "<title>" => ["Mr", "Dr", "Mrs"],
            "<person>" => ["Smith", "Black", "Grey"],
            separator => ", "

    should be "Dear Mr Smith, Dear Dr Black, Dear Mrs Grey"

this is used as an helper to generate code for metaprogramming purposes.

Jazzgarden

smart operations on objects - spreading commands over collections, taking 'slices' from object collections

easy creation of Value Objects

class Person
   defined by name, surname, age
end

intent of "Reading attributes of an object using 'defined by'"
    a person = Person new "Winnie","Pooh",70

    a person name should be "Winnie"
    a person surname should be "Pooh"
    a person age should be 70

existential quantification

intent of "Verifying if exist any"
    expect [1, 6, 10] exist any? |n| n>5
    dont_expect [1, 6, 10] exist any? |n| n>15

intent of "Verifying at least one element is true"
    expect [true, true, false] any true?
    dont_expect [false, false, false] all true?

collective action using several alias forms

people = [
    "john",
    "mike",
    "Sam"
]

story "Turning people names to uppercase"
    people to upcase should be ["JOHN","MIKE","SAM"]

intent of "Using shortcut form for collective action"
    people / reverse

should be ["nhoj","ekim","maS"]

people all reverse everyone capitalize

should be ["Nhoj","Ekim","Mas"]

object slicing

intents "Object Slicing - sorting by property"
    people sort by name every name
    should be [
        "bill","john","mike","paul","sam"
    ]

and random picking... I will just give a prozed example here:

people = [ "john", "sam", "mike", "frank"]
people pick one
people pick two
people pick two different

SmartStores

implicit mapping of directory and file structures to object aggregates. mapping of file types to classes

def sample smart store
SmartStore new ("intent-files/data")
end

story "Opening up an order"
repository = sample smart store
repository map! [child, of "orders"] => Order

an order = repository

order milan["20050906"]

retrieve

expect an order,

     to be Order new
             "Chairs"    => 18,
             "Laptops"   => 10,
             "Desks"     => 7

Clay

all my intents for Clay are very poor. I'll describe it another time.
what it does is to let you improvise the creation of objects and their attributes without needing to declare any class for them.

Highrise

a small financial framework

story "Using Cashflows"
Let's now deal with cashflows

with Conventional discount =

continuously compounded yield

    we expect about 271.67748, as the
        present value of
          Cashflow [

100 at 1 year ,

100 at 2 years ,

100 at 3 years

],
with interest rate at 5 percent

The other stuff is a bit more articulate and I'll leave it for another post :-)

RSpec as a DSL

2006-01-12T02:02:00.000+01:00

I just saw Steven Baker's code from RSpec when pointed there by Victor Cosby.  It looks a lot like my Intent framework.

I'll need to do some code reading here

Modern Languages

2006-01-12T01:43:00.000+01:00

Just some new languages to check out:

* Boo on codehaus

* Io , a small language

Let the Code DRY - later on..

2006-01-03T02:58:00.000+01:00

I finished writing the first draft of the SnapshotEngine code that I wrote about in the previous post. I produced it by copying and modifying snippets of code from the FactEngine, rather than subclassing it.

The result is much much clearer code.

True, there is some duplication, but I am now in a better position to decide what can be abstracted. I have detected a few common methods and I might put them into a common superclass or into a mixin utility module. I might even decide to not abstract it. The two classes could still develop in quite different ways and I may not want to tie them together yet.

Let code DRY on its own: Duplicate, Scan, Refactor, Abstract

2006-01-02T22:17:00.000+01:00

Tonight I spent several hours trying to get a piece of code of the Intent framework working. As usual these mistakes tend to be due to the wrong kind of laziness and to a false perception of coding economies.

I had this set of classes handling 'facts' - a recording of certain chosen outputs of a piece of code - and I wanted to add a new feature called 'snapshots'.

When you create a snapshot all the outputs of your program that would go to stdout are implicitly redirected to a file where they are stored and later used for a pretty raw form of regression testing. Snapshots looked to me like a specialized form of Facts, so what I did was to inherit from my FactsEngine class a SnapshotsEngine class, and I started building on that.

However as I was halfway through my top-down implementation (can I test first a test first framework? :-) I started realizing that the workflows of the two engines were not as similar as they seemed to me from an initial high level view. There were a few annoying details that kept getting in the way. Some state that should have been initialized, some step that was skipped, some more steps that needed to be added.

Soon enough the SnapshotsEngine had become an unreadable patch of the FactsEngine, that also had to be 'abstracted' to allow hooks for the SnapshotsEngine. By the way, nothing worked anymore and I started downloading Komodo so that I could use a debugger.

As I am writing I start feeling that resorting to debugging is like an admission of failure. I tried to don't repeat myself by going for inheritance, but I did it a bit too early.

DRY - Don't repeat yourself - should be interpreted in a teleological sense. The code should drift to a DRY state. Starting out DRY is not always the best way to get it right, as it is far too easy to fall into upfront design and believe that you really know things that you don't know only because you are able to generate early abstractions.

I find that the following sequence works well to produce DRY code:

Duplicate - start out by creating your code by copy and paste. Yes, I mean it. Get the bits that work and produce something working.
Scan - perform an eye scan of the original code and the duplicated modified code. Spot points of genuine semantic similarity and see if you can make the code more expressive by abstracting them out.
Refactor - apply a set of refactorings and Scans to extract the pieces of common code.
Abstract - look for opportunities of abstracting together the common pieces that you extracted as a superclass or as an aggregate/utility class. Look for overall architectural and design patterns of composition and inheritance.

What I found out is that a DRY, but bad abstraction is much much worst than duplicate code. Duplicate code can still be abstracted in a clean way, and it can also be pretty easy on the eye even if it is quite verbose and repetitive. Code that has been badly abstracted is obfuscated and hidden behind ad hoc abstractions and technical tricks that make it unreadable.

So, don't DRY your code. Apply the DuScRAb sequence and let the code DRY on its own.

Update: Table of Content

2005-12-31T00:27:00.000+01:00

I have updated the Liquid Development ToC with the lastest posts.

Tests as Storytelling

2005-12-30T23:48:00.000+01:00

If you look at tests as your main product and to code as just an implementation of the intent expressed by tests, then we start looking at tests with greater respect and attention.

Tests deserve refactoring. They should be refined and honed so that intent is expressed exactly in one point. Well, ideally.. :-)

Tests should be read out as a story, as an explanation, as examples.

But they shouldn't be boring saying the same things over and over with little variations, in the hope of catching inconsistencies by brute force.

Reading through test should be like reading through an explanation of the system, showing you how to build up layers of abstraction and sometimes going deep in a concept, exploring all its facets.

Intent 0.4 - Intents, Stories and Facts

2005-12-28T00:35:00.000+01:00

I have been keeping myself busy around christmas time. I have corrected quite a few points of Intent and Proze, I have added a couple of examples, extended the functionalities and improved the layout.

You can download Intent-0.4 from RubyForge.

Once you have downloaded the package and made it available in ruby's load path you can run some of the samples in the demo directory.

I have already detailed intent_of_mathematics in another post, but it's worth to point out a couple of changes.
For a start I have added support for Facts. A fact is a lazy developer's way of writing test. You get some code that works and you literally save its context and its results, allowing you to freeze the implicit intent of this code.

This is not really intent-first development, but it is still a step towards capturing intent.

The following code records a fact about divisions:

fact!("Result of Division"){
    given "area",   a = 100
    given "height", h = 5

    follows "base", a/h
}

the fact get saved under the "facts" subdirectory as Result_of_Division.fact.xml. The xml looks like this:

<fact id='Result of Division'>
    <area>100</area>
    <height>5</height>
    <base>20</base>
</fact>

I tried to make it readable and understandable on its own, so that even a different developer will be able to understand the intent of that fact.

If the question mark of the fact call gets changed to a question mark (or simply removed)

fact("Result of Division"){ ...

then we switch from recording the fact to verifying that the fact is still true.

When I run a reality check on the intent (F5 in SciTe from the intent file) I get the following report:

---------- Reality checking Adding One ----------
Consistent intent: ..1..
Consistent intent: ..2..
Consistent intent: ..3..
---------- Reality checking Commutative Property of Addition ---
Consistent intent: ..3..
Consistent intent: ..5..

which means that the early intents are ok.

---------- Reality checking Comparison - Lesser Than ----------
Consistent intent: ..true..
**BROKEN** intent
    expected     ->false<-
    but got     ->true<-

    see: intent_of_mathematics.rb:14
            D:/apps/ruby/lib/ruby/1.8/intent/demo/intent_of_mathematics.rb:14:in

which points out a broken intent and allows you to jump direcly to the offending intent code:

intent_of("Comparison - Lesser Than") {
expect 0 < 1
expect 1 > 2

Our division fact returns the following:

---------- Reality checking Result of Division ----------
Consistent intent: ..'area: 100'..
Consistent intent: ..'height: 5'..
Consistent intent: ..'base: 20'..

we see that our saved fact has not been violated.

The multiplication unfortunately is broken:

---------- Reality checking Result of Multiplication --
Consistent intent: ..'base: 20'..
Consistent intent: ..'height: 5'..
**BROKEN** intent
    expected     ->'area: 101'<-
    but got     ->'area: 100'<-

    see: intent_of_mathematics.rb:46
            D:/apps/ruby/lib/ruby/1.8/intent/demo/intent_of_mathematics.rb:46:in

as we can see the area is wrong..

------------ Prozing ------------
prozing intent_of_mathematics.rb ...
---------------------------------

Then the intent gets prozed and produces a readable prozed file:

require 'intent/all'

intent of "Adding One"
     0 + 1 should be 1
     1 + 1 should be 2
     2 + 1 should be 3

....

intent of "Recognising Illegal Operations"
    expect exception ZeroDivisionError
        when trying to calculate
        5 / 0

story "Calculating the Area of a Triangle"
    base   = 10
    height = 5
    area   = base * height / 2

    expect 25, as area

....

fact "Result of Multiplication"
    given "base",   b = 20
    given "height", h = 5

    follows "area", b*h + 1

fact "Result of Division"
    given "area",   a = 100
    given "height", h = 5

    follows "base", a/h

Intents are supposed to capture small grained intentions as a design device.

Stories are descriptions of typical cross-functionality scenarios.

Facts are frozen representations of implicit intent.

In the next release of Intent I will also add Snapshots, an even rougher way of capturing intents. A snapshot will intercept and memorize a set of input and output streams (puts and gets) and will save them as unqualified facts.

What I would like to do is to create a full development path that goes from raw implicit-intent snapshots to full fledged small granularity intents.

I envision the following sequence:

snapshot --> fact --> story --> intent

I was forgetting the final report. I'll adjust it a bit so that it fits on the web page:

--------------------
Broken Expectations
---------------------------------------------------------
* intent: Comparison - Lesser Than - #2: expected false, but was true
* fact: Result of Multiplication - #3: expected area: 101, but was area: 100
---------------------------------------------------------

---------------
Broken Intents
---------------------------------------------------------
* Comparison - Lesser Than
---------------------------------------------------------

---------------
Broken Facts
---------------------------------------------------------
* Result of Multiplication
---------------------------------------------------------

we also get a nice report for each category and an average of expectations per intent (a good proxy of intent granularity and expressiveness)

----------------
Reality Checking
---------------------------------------------------------
    intents: 4                stories: 2
---------------------------------------------------------
passed intents: 3/4     passed stories: 2/2
broken intents: 1       broken stories: 0
----------------------------------------------------------
    facts: 2               expectations: 17
----------------------------------------------------------
passed facts : 1/2    passed expectations: 15/17
broken facts : 1      broken expectations: 2
-----------------------------------------------------------
expectations per intent: 2.3
--------------------------
    powered by >>Intent<<
--------------------------