On Friday I spoke at the 2010 Dallas Tech Fest. This is a great event and I look forward to it every year. This year, I spoke on the 10 Practices that every developer needs to start right now (slides). I also, found out later, that I had the most attended talk of the day – awesome! One of the things that I cover in that talk are the principals of SOLID – and that’s what I was heckled about.
The goal of the SOLID principals is to write better, healthier OO code that is easier to test, maintain and develop with. Essentially, SOLID embodies object oriented development done right.
It’s important to note that SOLID is a set of principals that embody the what and the why of certain OO practices. SOLID is really light on the specifics of how. The distinction is important, in that this is part of what allows the SOLID principals to be embraced across various languages and environments including Java, .NET, PHP, Ruby, etc… So, for example, the Open Close Principal can be achieved through poly-morphism, strategy pattern, IoC, virtual methods, dynamic mix-ins (ruby); the same can be said for the Dependency Inversion Principal – these are two how’s & why’s that tackle the same problem from two different directions. The application of these principals is often very similar.
You can imagine that in that context, it would be difficult to fully embody the full breadth and depth of all of the SOLID principals in a talk where the entire set of SOLID principals were one sub point (two slides) of a 10 point talk.
My goal was to pull out a couple of practical nuggets to help people embrace the SOLID principals – namely, to code against Interfaces and to adopt a Dependency Injection approach to development. In my opinion, if a developer will take on those two practices – that alone will take them close to embodying about 90% of the SOLID principals.
Imagine getting the why wrong, but being right on the how. Let that soak in for a minute.
It’s like telling your kids to wash their hands or their pants will fall off. It’s a non-sequitur, they are un-related – and yet, people should still wash their hands. That’s what happened on Friday – and what I was heckled for.
I explained the how (what you should do with your code) correctly, but miss-matched the why. I was giving the why of Open Close Principal and Dependency Inversion Principal and attributing it to Liskov Substitution Principal – my mistake.
Should I have been heckled for that? Probably not. Not many people do as much public presenting as I do, and most would find it difficult to handle a heckler – it can throw off your whole talk (especially when you’re only on the 2nd point!) Fortunately, I’ve been doing this for a while, and I don’t think that it threw me off much, as one attendee observed on twitter
Why am I blogging about this?
First, for transparency. I was wrong in my explanation of LSP (it was a minor sub-point to my talk, and not the overall goal of my talk – but still). Second, I reached out to the person that heckled me via email the following day, and we’re back on good terms. He’s apologized for being inappropriate and we’re having lunch in the next couple of weeks. I honestly didn’t know who it was that heckled me at first, I found out later and then realized that we had exchanged (positive) emails in the past, and so I reached out to him. Since he is active in the community, and at least a couple of other people recognized him in my session – I felt that it was important to let you all know that we’re all good – and that there were no hurt feelings.
The community is strong, no one is ever right all of the time (gasp!) and it’s important that we continue to move forward as an industry together.
Incidentally, what caused me to go back and re-look at LSP, was not from being heckled, but from a very nice email that someone else sent me after my talk – I really did appreciate that email, so to the person that sent it, thank you.
Also, if anyone is interested in looking at my slides (the last 3 slides are all of the image credits) they are – and have been for some time – posted on slideshare; if you’re interested in some of the broader blog posts on this subject, they are posted on my blog including my more complete write up on SOLID (awaiting a Liskov update!)
Thanks – Happy coding!