http://scottishdevelopers.com/tag/solid/
http://sydney.yowconference.com.au/
I won't spoil it by writing all the points here - just some pearls.
* The Open/Closed principle is redundant because it is already covered by the Liskov substitution principle.
* Bob Martin's view of the Dependency Inversion principle is in fact the Single Responsibility principle.
He suggests 5 more principles - but I won't spoil it by listing them here. Go see it!
Also, not everybody has the possibility to visit a conference in Australia.
I recently asked Kevlin if a version would be made available - this was his reply:
"Not yet. I'm doing a version of it at @yow_oz next month. I think they'll be recording it — last year's talks went up quickly." https://twitter.com/KevlinHenney/status/402743019956604928
The conference has just finished, and the website where the talks will go up seems to be here: http://yowconference.com.au/
The biggest thing I think many programmers suffer from is wanting to have too few objects with big, ugly methods inside.
More objects, fewer methods, smaller methods is often the answer to managing complexity, but it seems like humans don't like appropriately recognizing the complexity of the problems they are working with, even when confronted with the mess they make to solve them.
My intuition is that in the junior-developer brain, a problem that's big enough to justify using design patterns and SOLID code is a really scary thing that's simply going to take more time than they have. They aren't comfortable with the idea that they can't contain the whole problem in their heads and inside just one or two files, so rather than breaking the problem apart so they can work on one piece at a time, they pick a part of the problem they can start with (usually something involving manipulating strings or very simple models... something that's simple to solve with a couple of methods) and "organically" grow it into more and more methods and shared state until it's bigger and scarier than the problem they started out with!
I've watched people's eyes light up with anxiety as they are introduced to a big and complex but well organized and decoupled solution that contains a lot of classes... the immediate reaction is "What a mess! There are so many files!" Their first instinct is to want to combine things together, thinking that it would reduce complexity or produce some kind of "savings." They will choose tight coupling over "more code" every time, which is ironic because as soon as a problem caused by the tight coupling crops up, the first instinct is to liberally apply more code until the problem is solved.
Nowadays I try to follow good coding principles on my home projects and the small parts I might have some responsibility over.
But for the overall projects, I don't care any longer. It is just playing Quixote on the enterprise, even more so if the project has outsourced or offshored components.
Personally, I like the Alan Kay's definition:
>OOP to me means only messaging, local retention and protection and hiding of state-process, and extreme late-binding of all things. It can be done in Smalltalk and in LISP. There are possibly other systems in which this is possible, but I'm not aware of them.
http://userpage.fu-berlin.de/~ram/pub/pub_jf47ht81Ht/doc_kay...
Talk about creating confusion in the mind of the reader. They might have applied some of the sold principles to this article and separated out this completely orthogonal concern. This is what annoys me about Wikipedia sometimes. It's full of "editors" hijacking articles to propagate their manifesto of the week instead of just sticking to the subject.
Object orientation is a black box to many and many people think they program object orientated, only because they program in Java or C#. But that's not true. Object Orientation is about program architecture. Learning OO-Pattern is essential for this task and to know the guiding principles of good architectures. Start SOLID and you are save.
Interesting take on the open closed principle
