Thanks!

Everything worked fine for me except when the tests were run by Integrity (constant integration server). But after installing celerity for the standard ruby distribution, it is now working under Integrity as well. It doesn’t make any sense to me, but…

I even tried Panic’s Coda a few days ago. It has some nice features.

Indeed, crazy stuff, I was bited by it more than once, and I lost precious time. I found out how to setup emacs to save the backup files in a different folder instead of saving it in the same level as the file, which causes these kind of problems. I will be postin about this soon.

Thanks for visting my place

Marcelo.

I agree, OO is language-agnostic, and that was what I tried to communicate in this post, even though I ended up speaking about the common fact that people often underestimate OO skills/knowledge.

However, people get so overwhelmed about Duck Typing, Meta-programming, TDD, BDD that they think OO is just a necessary evil, which is not true (Take for example the bad press about Java frameworks and Design Patterns in the Ruby community, they all sum up to the equation).

TDD/BDD books don’t give enough importance to OO while they teach you about tests. They just say you will find about concepts as you go, but they don’t dig down into the subject.

And here’s what I want to do in my next essays: Analyse BDD (Cucumber and rSpec) and OO design, and how one can get the most out of both worlds — following TDD/BDD and still have a good OO architecture and how to keep the balance (avoid over-engineering, which is common when you don’t follow a TDD/BDD approach).

Take a look at this short post of mine, where I elaborate a little bit on this: http://www.fullofcaffeine.com/2009/10/23/are-tests-tdd-more-important-than-architecture/.

This comes from my experience. Many say BDD is the way to enlightenment, and I’m a believer. However, I’ve seen code well-backed by tests (Cucumber & rSpec) that was still spaghetti and not OO whatsoever.

I think there’s an area of opportunity there for some additional study and improvement — How to be true agile but still care enough for the OO architecture.

Let me know what you think!

Marcelo.

If objects are nouns and methods are verbs…
Don’t mix your nouns and verbs.
Your verbs should involve as few nouns as possible (this means fewer parameters, but also fewer nouns in method names).
Keep your eyes open for missing nouns. If you omit concepts, you will start to see your verbs getting polluted by more and more nouns.

For example, if you’ve got:

new HttpResource(“www.google.com”, 80)

you’ve got two nouns where there could be one. The missing concept that can reduce the number of nouns involved is Port (since a Port exists only on a host).

This OO way of thinking is something that no language can enforce. Even in a language like Smalltalk or Delphi, you still make decisions about what concepts get their own object and what ones reuse some old (and possibly inappropriate) object. It’s pretty rare that I see code where someone has created too many classes. More often, classes wind up as a mix of concepts and the design suffers (or completely falls apart) as a result.

Just look at the composition of something really awful in terms of OO design like the Java network package. Why is there no Host object? That’s a concept. Why no Port object? That’s a concept. Instead, we have piles of “int” values being passed around as parameters. If you implement a really nice object model for networking, you boil out tons of repeated non-OO code. Want to open a connection to http://www.google.com?

Socket socket = new Host(“www.google.com”).port(80).openSocket();

But since it’s nice OO code, you can also do URL-like things with it (only without the horrible URL class):

Host google = new Host(“www.google.com”);
Port port = google.http();
String content = new HttpResource(port, new ResourcePath(“/foo/bar.txt”)).get();

Want to see if google is up by pinging it?

if (google.isAlive()) {

}

Etc…

A lot of the Java core is just too painful without adding some OO around it.