Last year I attended a couple of developer best practices sessions and came away liking them quite a bit so I figured I should attend at least one this year as well. The first one this year was basically five things which Frank Buschmann and Kevlin Henney collectively considers to be important to developers.
Of all the things they pulled out of their hats I liked their points on expressiveness the most. They talked about bringing out concepts which are implied in both the architecture and the low level design of a solution; something we strive to do as well. One of the key aspects when writing code I find is that more often than not code is written once and read dozens of times which means optimizing for readability is not only a good thing to do but the only thing to do.
An example of the above are variables of type string. Usually these guys contain a lot more than just mere strings, e.g. XML, social security numbers, etc., instead of going with just the string you could go for a class of type SocialSecurityNumber which would be a lot more explicit. The little things count.
Developer habitability is a term they touched on which I quite like. The idea is that if we create nice usable solutions which are easy to understand and simple in their composition developer habitability is increased – basically the code place is a nice place to live :)
Two-way synchronization is a notoriously difficult challenge to solve. Mostly when I’ve come up against this thing I’ve gone for a simpler solution like selecting a data master which overrides the slaves. Naturally I was excited to learn that Mike Clark was giving a talk on Microsoft Synchronization Framework which tackles this very issue.
Sync Framework actually forms the backbone of tool you might know already: Sync Toy which sync files across the network, file system, or whatever. Certainly a neat feature Sync Framework is about much more than that. It basically enables us to synchronize our custom data stores which to me is very exciting.
Included in the box is support for all data stores which have an ADO.NET Data Provider so we’re talking all major databases here. Additionally the framework gives us rich hooks so we can grab any step in the pipeline and modify it to our heart’s content.
Actually my words won’t really do it justice so instead take a look at this video; basically the entire talk. Once you’re done with that go play with Lively Kernel live on the web.
Keeping in the same vain I decided to go take a look at Erik Meijer talking about his current project: Volta. Volta is a project aiming to allows us to defer decisions on deployment model to a much later point in the project than what we currently do today. The current state of affairs is pretty much that we need to decide very early in the project phase which might or might not make sense. In any event having the option to defer those kinds of decisions is always better right?
Last year Erik gave the keynote at JAOO and talked about Volta at which time I was skeptical to say the least thus it was interesting to actually see that there’s some meat on the project after all. The idea is interesting to say the least and I look forward to seeing where it goes from here.
One is the big topics for me last year at JAOO was test driven development so I was curious to see whether new stuff had come up in the intervening time from then to now. Giving the talk on TDD was Erik Doernenburg. I won’t go into a lot of detail about the talk because as it turns out not much have changed in the span of a year.
What was interesting for me to note is that our work with unit testing and test driven development at Vertica has paid off handsomely as everything that ThoughtWorks, which I would describe as the thought leaders in this space (no pun intended), are doing is basically what we’ve spent the last year implementing and I’m happy to report that we’re at the point where the culture is basically sustaining that particular way of doing code.
So a year and a half ago I set the goal of become better at doing unit testing and my great colleagues have ensured success in that area. For the coming year the focus will be on builds, continuous integration, and release management. To me these are natural steps in our continued development of our way of doing things … and it’s fun too :)
The opinions expressed herein are my own personal opinions and do not represent
my employer's view in any way.