Folks, if you’re not willing to buy tools to get your job done faster/better – please do us all a favor…

He and I had the related Twitter discussion which you can follow, as well as a chat offline to further clarify what we meant. However, I thought it was a subject rich enough to deserve more than 140 characters in explanation. It’s my stance that the quote above at first read is essentially saying if you aren’t willing to buy productivity tools, then we’d be better off without you. David has since explained that he was really targeting people who complained about built in tool support or the lack thereof and that if you weren’t willing to buy the tools, stop complaining and just do your job. However, several other people agreed with Dave’s quote as written and I fairly strongly disagree so let’s look at the quote as it is.

My stance is that this is a purely economic decision at its most core, one that if taken at face value, expects developers to take a financial risk, e.g. pay for a yearly subscription to Code Rush or Resharper, and accept in return a non-financial reward, e.g. greater productivity which we’ll assume leads to greater happiness. Additionally, an employer who can convince all his employees to buy their own subscription reaps almost immediate rewards while taking on none of the risk. This is a bad economic decision for an employee to take. There is an edge case which nearly everyone brought up in their agreement with David and that is a craftsman. We’ll discuss that in a minute.

One point that’s critical here is that we’re talking about salaried employees and not independent contractors of any kind. When I first objected to Dave’s remark, I questioned what other profession expects the employees to buy their own productivity tools. I don’t think there are any outside of independent contractors. This is an important distinction because contractors can pass the cost of their increased productivity on to the consumer through either higher prices or longer engagements if they choose not to use the productivity tools. Salaried employees do not have that option. Several people argued that employees who were more productive would be rewarded in the long run but again, this is not a good economic bargain since future returns on my economic risk today are inherently, well, risky. Maybe the employer lays me off or pays me less than my productivity cost me.

Looking at it from another angle, by convincing me either implicitly or explicitly to pay for tools to increase my productivity, my employer has also lowered his salary costs while gaining in output. Again, in an economic agreement, this is a big loss for me. Of course, David didn’t mention the employer in all this but the assumption is that if I have to pay for my productivity tools, it’s because my employer refuses to do so for whatever reason.

Granted, I may have a choice in the matter. I may choose not to work with the tools. I may choose to get another job. But all of these come with associated costs, costs that must be weighed when making a decision.

In the end, the best employers ought to provide the best tools for their developers in an attempt to get the very best employees. The best employers do this because they know it’s in their best interest to focus on the long term return of having the very best employees while the worst employers focus on the near term return of the cutting costs. This is true across many fields, not just software development.

What about that edge case? Here’s where my thinking converges with David’s sentiment. Craftsmen always work with the best tools because their work is qualitatively different than that of the average software developer. They want to operate at the highest level of efficiency in order to achieve the quality of work that their internal motivation demands. Of course, the irony in this is that typically craftsmen refuse to work for employers who expect them to buy their own tools because that is a sign of the type of work or environment they can expect.

Overall, I don’t think it should be the employee’s obligation to provide themselves with productivity tools. They agree to do a job to the best of their abilities when they join a company. If there are tools that enhance their abilities, the employer should provide them as an investment in the long term gain of more productive and ultimately happier employees.

Of course, all this said, I choose to buy my own tools. I do this in part because I want to have them after I leave a given company but also so that I can use them in my own personal development as a software developer. I’m light years away from being a craftsman but I suppose striving to be one is the next best thing.

Often, traditional communication approaches are overlooked. Over time, signage and other messaging becomes part of the noise that is intentionally ignored. Innovators find new ways to slap you in the face and take notice. Check out this approach to “Go Green” posted in a dorm in Claremont McKenna college. Thanks to Jason Soll and Daniel Pink from TED…

Topics covered:
- The value of value-based planning
- The what’s and why’s of Naked Planning
   – Requirements waste
   – Queues and flow
   – Minimum marketable features
   – The ultimate definition of done
- We don’t need no stinking iterations
- How to handle releases
- Naked Planning vs. kanban
- Naked Planning and estimation
- MMFs that require architectural change
- Handling emergencies
- Continuous flow, Software Craftsmanship and the evolution of agile

References:
- Arlo Belshee on the Agile Toolkit Podcast: http://bit.ly/jz0V9
- Tom DeMarco – Controlling Software Projects – http://bit.ly/1Q4gTC
- Steve McConnell – Software Estimation – http://bit.ly/gZjYX
- Software Craftsmanship Manifesto http://manifesto.softwarecraftsmanship.org
- Ben Rady’s Blog – feedbackjunkies.com

If you work on the web long enough, sooner or later you’ll cross paths with a Microsoft .NET project and all of the tooling changes that come with it. Visual Studio, IIS, Internet Explorer, and God help you - TFS. The Microsoft development stack is flexible, capable, and powerful. However, they are a 180° shift from the lightweight tools that most Mac developers have come to fiercely love.

When working on projects at Improving, I consider myself a fully integrated (web) developer with a few exceptions:

• I don’t use the debugger (in Visual Studio)
• I rarely need to compile
• I never touch a database
• I don’t need IntelliSense or other IDE helpers
• I test against IE, but don’t use it otherwise

I don’t need all the functionality provide by Visual Studio and other Microsoft developer tools. So why deal with all the overhead (and remembering to alt-tab instead of cmd-tab)?

Recently I discovered (with the help of my team) the perfect environment for me. It eliminates (most of) the need to fumble around in Visual Studio and puts me back in front of my go-to tool: Textmate. (Click here for some of my favorite TextMate features).

Maximum Cake

This configuration looks a bit complicated, but it’s not.

• All of the project source code lives inside of a Windows 7 virtual machine and is managed via Subversion
• IIS is pointed at my source directory and serves up the web project via HTTP, making it accessible via localhost and outside of the virtual machine
• My source directory is mounted in OSX via an SMB share and pulled into TextMate

Essentially, I use Windows as web server, a file server, and as an occasional compiler. That’s it.

This is nirvana for me.

BTW, did you know that all MSDN subscribers with a Dev edition of VSTS 2008 get an automatic upgrade to VSTS 2010 Ultimate? Make sure your MSDN license is up-to-date so you get all the new stuff in 2010. :) 

My initial solution in Clojure was both ugly and uncompilable making it reasonably useless. I’ve been struggling with getting my head truly around functional programming and I finally figured that the solution to that was to do more of it. This summer, in another fit of ADHD and boredom, I bought the electronic version of Chris Smith’s Programming F#. Like most of my projects, little came of it until last night when I decided to work really hard on it for 30 minutes. I figured out Euler’s problem 1 in about 20 minutes and that made me think I should be able to handle Clojure as well.

It took a lot longer than 30 minutes but I finally figured it out in a way that didn’t require 85 lines of Clojure. I think the functional style is starting to sink in. Doing both F# and Clojure seems to hammer home the concepts because I can develop a solution in F# in a medium I’m comfortable in (.Net and Visual Studio) and then move to Clojure with a little more background to build from. The solutions are provided below as a reference.

def main(): sum = 0 for x in range(1, 1000): if x%3==0 or x%5==0: sum+= x print sum

This was the original solution in Python. After doing the F# and Clojure work, I came up with something shorter if slightly more obtuse:

reduce(lambda x, y: x+y, filter(lambda x: x%3==0 or x%5==0, range(1, 1000)))

Those two lambdas are not good for long term maintenance and aren’t that readable. A list comprehension in place of the filter would be a good deal clearer.

reduce(lambda x, y: x+y, [num for num in range(1, 1000) if x%3==0 or x%5==0])

So we’re down from 5 lines to 1 while retaining a good deal of readability. Maybe there really is something to this “Functional programming makes you a better programmer” stuff.

In unimproved F# (I’m open to suggestions):

let result (acc : int) x = if x % 3 = 0 || x % 5 = 0 then acc + x else acc
List.reduce result [0..999];;

And finally, in what I think is decent Clojure:

(defn isdiv [x] (or (= (rem x 3) 0) (= (rem x 5) 0)))
(reduce + (filter isdiv (range 1 1000)))

Sorry for not having syntax highlighting for the Clojure or F# code, they would both be a great deal more readable. However, it’s interesting to see in Clojure how all functions are first class, e.g. I can pass the + operator to the reduce function instead of having to define a lambda as I did in Python.

I have a feeling the Clojure code could be more succinct but for a first working cut, I’m pretty pleased with it. It’s clean and easy to read, even for someone like me with little exposure to the prefix notation and all the parens.

Overall, I feel less dumb than I did when I woke up this morning. I’m guessing the beer I drink at tonight’s Halloween party will fix that though.

BTW, some of the shortcut keys I love the most I forgot to mention and they aren’t listed on the Wikipedia on Windows 7 features.  Those keys are the Win + <a number> keys, which correspond to taskbar buttons you have in your task tray.  For me, pressing the Windows Key plus the number 1 (aka Win + 1), launches Internet Explorer.  Win + 2 launches the Folder Explorer.  They work all the way up to Win + 0 for the 10th application in the tray.  If your application is already open, the key just brings the window to the front.  If you really want a new instance, add in the shift key.  For example, Shift + Win + 1 opens a new Internet Explorer window, even if you have one open – just like shift-clicking on the application icon.  As far as I know, all of the shortcuts that I mention in the podcast and here are documented on Microsoft’s Windows 7 page on Keyboard Shortcuts.

If you want to see some examples of themes that I mentioned in the podcast, check out this page of Windows 7 additional themes.  And if you’ve just installed Windows 7, make sure you also get Windows Live Essentials with Live Messenger and it’s friends, as well as the new Windows Security Essentials for FREE anti-virus and anti-spyware protection. 

Happy Windows 7 launch day!

Links:

- Virtual PC: http://microsoft.com/virtualpc
- Booting Win 7 from a VHD: http://www.hanselman.com/blog/LessVirtualMoreMachineWindows7AndTheMagicOfBootToVHD.aspx
- SlySoft’s Virtual Clone Drive (was by Elaborate Bytes): http://www.slysoft.com/en/virtual-clonedrive.html
- Wikipedia page with Windows key shortcuts: http://en.wikipedia.org/wiki/Windows_key/
- The Dallas C# Special Interest Group: http://www.dallas-csharp-sig.com/
- Todd and Chris Tullier’s Workshop at PDC: http://microsoftpdc.com/Sessions/Developing-Quality-Software-using-Visual-Studio-Team-System-2010
- Todd Girvin (@tmgirvin): http://tmgirvin.com/

As always, please send us feedback to: feedback at improvingpodcasts.com

WriteThisNotThat.com is a community-based site dedicated to building a library of good development practices by profiling the really ugly ones. By really ugly practices I mean that 700-line-long method that makes you vomit in your mouth a little everytime you think about it. How about that old class that’s 90% unreachable code because it’s covered in hacked-together bandages? That’s what we want to see! This site is welcome to all developers regardless of language (even VB) or experience level. Seasoned architect? Great! Straight out of college? Even better! 

We’re in the process of courting some sponsors so that we can spin up a monthly contest based on your votes. Post your ugly source code and there might be a little something in it for you. 

Drop by when you get chance. If you don’t learn anything the first time around it will atleast be good for a chuckle or two. Next time you run across some especially gnarly source code, share it with us! We’d love to see it! 

If you like the site, please don’t keep it a secret.

Fluent interfaces allow developers to work with objects in a more natural and readable fashion by chaining methods together. By building a fluent interface I can make my API not only more concise but much easier to use. Take a look at the following code:

Wait.Until("1:45 PM").Then(() => DoSomethingImportant());

By chaining methods together we’re forming a sentence describing exactly what we want to happen. We want to wait until 1:45 PM and then do something important. But how do we implement this interface? Wait is actually a static class that defines the For and Until methods. Let’s take a closer look to see what’s going on under the covers:

public static class Wait
{ public static WaitContext For(TimeSpan waitFor_) { if (waitFor_ <= TimeSpan.Zero) throw new ArgumentOutOfRangeException("waitFor", "The supplied time span is negative"); return new WaitContext(waitFor_); } public static WaitContext For(string waitFor_) { TimeSpan waitFor = default(TimeSpan); if (!(TimeSpan.TryParse(waitFor, out waitFor))) throw new ArgumentOutOfRangeException("waitFor", "The supplied time span is invalid."); return For(waitFor); } public static WaitContext Until(DateTime waitUntil_) { if (waitUntil_ <= DateTime.Now) throw new ArgumentOutOfRangeException("waitUntil_", "The supplied date is in the past."); return new WaitContext(waitUntil_); } public static WaitContext Until(string waitUntil_) { DateTime waitUntil = default(DateTime); if (!(DateTime.TryParse(waitUntil_, out waitUntil))) throw new ArgumentOutOfRangeException("waitUntil_", "The supplied date is invalid."); return Until(waitUntil); }
}

Let’s take a second to examine this class. As you can see, we are defining overloaded versions of the Wait and For methods allowing us to supply a specific DateTime or TimeSpan or a string that can be parsed into the appropriate structure. By overloading the two key methods to allow strings we can make our interface more natural and easier to read. Each method first performs some validation logic then returns a WaitContext that defines how long we are going to wait before executing a given block of code. Let’s take a look at WaitContext so we can complete the full picture of how this is all going to work:

public class WaitContext
{ internal WaitContext(DateTime waitUntil_) { _waitUntil = waitUntil_; } internal WaitContext(TimeSpan waitFor_) { _waitFor = waitFor_; } private DateTime? _waitUntil; private TimeSpan? _waitFor; public void Then(Action toDo_) { if (toDo_ == null) throw new ArgumentNullException("toDo_"); ThreadPool.QueueUserWorkItem(new WaitCallback( new Action<object>(o => { Thread.Sleep( _waitUntil.HasValue ? _waitUntil.Value.Subtract(DateTime.Now) : _waitFor.Value); toDo_(); }))); }
}

The WaitContext can only be initialized within the Wait class defined earlier with a DateTime or TimeSpan structure. The Then method is the one that actually does all of the heavy lifting. After checking that the provided Action delegate is valid we then spin up a new thread. Within the thread we’re going to wait for or until the specified time then invoke the provided delegate. Since we’re potentially working with multiple threads here be sure to make the delegate that you provide thread-safe. If you’d like, it would be pretty simple to include some sort of callback mechanism within the delegate that you provide. 

That’s pretty much all there is to it. Keep in mind that there is no one tool for every situation. Fluent interfaces just seemed to be a particularly good fit this time around. I’d like to add some additional functionality in the near future that would allow me to continuously invoke the delegate at a given interval. I don’t need that right now but I’ll probably add it later.

This source code is free to modify and use for whatever purpose. All that I ask is that you give a little credit where credit is due and let me know how you’re using it.

Happy hacking!

Checkstyle allows you to exempt sections of code from the checks it performs by enclosing the section in special comments:

// CHECKSTYLE:OFF /* mess here */
// CHECKSTYLE:ON

There are times where such selective overriding of style checks is appropriate. Here's an example from something I worked on recently:

abstract class ExceptionLoggingCallable<V> implements Callable<V> { // ... // CHECKSTYLE:OFF -- We advertise Exception because the method we implement does, // and because we want Exceptions in general to be rethrown. We catch Exception // and Throwable in order to log them and rethrow. public final V call() throws Exception { try { return doSomethingThatMightRaiseAnException(); } catch (Exception ex) { logger.error(ex); throw ex; } catch (Throwable ex) { logger.fatal(ex); throw new RuntimeException(ex); } } // CHECKSTYLE:ON protected abstract V doSomethingThatMightRaiseAnException();
}

I specifically chose to subvert the IllegalCatch and IllegalThrows checks here for what I believed to be legitimate reasons. I gave those reasons in the CHECKSTYLE:OFF comments, so that readers would know it was not a lightly-taken decision.

Now consider the following code. Do you believe the Checkstyle checks are subverted for good reason?

 // CHECKSTYLE:OFF private void startLateCount(String localName, Attributes attributes) { if ("_LATE_COUNT".equals(localName) && currentLiability != null) { int timesThirtyDaysLate = 0; try { String thirtyDayAttr = attributes.getValue("_30Days"); timesThirtyDaysLate = timesThirtyDaysLate + Integer.parseInt(thirtyDayAttr); } catch ( NumberFormatException nfe ) { } try { String sixtyDayAttr = attributes.getValue("_60Days"); timesThirtyDaysLate = timesThirtyDaysLate + (Integer.parseInt(sixtyDayAttr) * 2); } catch ( NumberFormatException nfe ) { } try { String ninetyDayAttr = attributes.getValue("_90Days"); timesThirtyDaysLate = timesThirtyDaysLate + (Integer.parseInt(ninetyDayAttr) * 3); } catch ( NumberFormatException nfe ) { } currentLiability.setMonthsDelinquent(timesThirtyDaysLate); } } // CHECKSTYLE:ON

My Checkstyle configuration caught brace-placement and empty catch block issues here -- but a cursory glance at the code should reveal a duplication of structure that is begging to be factored out.

Do not use CHECKSTYLE:OFF as a cloaking device that allows bad code to exist in the system undetected by tools. Use it as an apology for not being able to express the computation without breaking "the rules". If you must exempt some code from Checkstyle, explain why. If you see code snippets that are CHECKSTYLE:OFF'ed, ask yourself whether the reasons are legitimate, and if they aren't, refactor until the structure is improved and the intent clarified.

Same goes for any other static analysis tools that are there to help you, not annoy you.

In the beginner’s mind there are many possibilities,
in the expert’s mind there are few. – Shunryu Suzuki 

Anyway, our pre-con session at PDC is title Developing Quality Software using Visual Studio Team System 2010, and will be on Monday, November 16th.  Make sure you register for the pre-con when you register for PDC to reserve your seat.

In his blog “Pagan Tuna”, Herb Bowie offers a brilliant updated analogy that addresses the combined invidual and team behaviors on a project. It doesn’t hurt that his football analogy coincides with the feverish enthusiasm at the beginning of a new football season. Check it out here.

Links:
- http://www.houstontechfest.com
- http://en.wikipedia.org/wiki/Getting_Things_Done
- http://streamlinedmodeling.com
- Mike (@mikeabney): http://practicallyagile.com
- Allen (@allenhurst): http://ahurst.com

However, the iPhone’s Bluetooth support is not the best. I have an 8GB 3G, and had a lot of trouble with the audio cutting out. Worse, the same was true when I was on a call. I could usually hear just fine, but folks on the other end would tell me that my voice was cutting out. I was starting to blame the headset and was preparing to buy a more expensive model.

Fortunately, I noticed two important things. First, the podcast/music audio cutting out tended to only happen when the screen locked. This was true whether or not I pressed the lock or let the phone auto-lock. Second, I noticed that Apple’s iPhone OS 3.1 update mentioned attempting to fix problems with Bluetooth and wireless (Wi-Fi). In their case, they were trying to improve Wi-Fi performance.

Because of this, I decided to experiment a bit. I disabled the Auto-Lock feature and disabled Wi-Fi. Suddenly, I had no more skipping and cut-out problems. People said calls did not cut out either. I tested this way for about a day. I was able to get the audio to cut out by launching a CPU-intensive app, but only during the launch. Once the app was running, the audio came back with no more problems.

After that, I re-enabled the auto-lock. I locked and unlocked the phone. Still no cut-out problems. I then turned Wi-Fi back on. No cut-out problems. Then I locked the phone. Bingo! Audio started cutting out again. I disabled auto-lock, but the problem was still there when I locked the phone. Finally, I disabled Wi-Fi and turned auto-lock back on. No more skipping or cut-out problems.

It turns out that the iPhone is built such that Wi-Fi and Bluetooth share an antenna (presumably to share space). This causes problems when both are on. Apple seems to have found a way to manage this most of the time and even released updates to improve Wi-Fi performance. However, as has been true of iPhone Bluetooth support all along, they seem to have neglected to do the same for Bluetooth. Specifically, something seems to happen to the Bluetooth power (and possibly the Wi-Fi power) when the phone is locked. The combination of signal degredation from both being on and the phone being locked causes the problem.

The moral of the story? If you want to use a Bluetooth headset, disable Wi-Fi. If you want to use Wi-Fi, disable Bluetooth. That will get you the best performance. Now back to enjoying my wireless music while refactoring.

An article on Joel Spolsky’s Fog Creek office space Mike mentions: http://www.joelonsoftware.com/articles/BionicOffice.html

If you have experience designing agile team rooms or looking for real estate for software development, we would love to hear about it. You can provide feedback through comments at improvingpodcasts.com or send e-mail to feedback at improvingpodcasts.com.

This is your Tip of the Whenever I Get Around To It for this time period. Look for another tip whenever I get around to it.

My perspective:

My 40D, just after it arrived

My love for photography really didn’t start until November of 2007 when I bought a my first DSLR: the Canon 40D (blame Stephen and Jeremy for getting me hooked). The 40D was a lot of camera for a beginner, but I quickly grew into it.

I loved the 40D, so much so that I even swayed Alex, a long time Nikon user, to make the switch to Canon. I loved the 40D’s build quality, high-speed burst (6.5FPS), and overall responsiveness (especially with fast glass).

My go-to lens was the Canon EF-S 17-55mm f/2.8 IS. I can’t say enough good things about this lens. It combined a fast f/2.8 aperture with built-in image stabilization (IS), making it damn near perfect in most occasions. I really, really miss this lens.

The did 40D had a few shortcomings, namely sensor resolution (10MP), ho-hum LCD screen, and OK, but not great ISO performance. However, my upgrade to the 5DMKII was less about the 40D’s short-comings, and more about the allure of a full-frame sensor, HD 1080P video, and a (more) pro body.

What I still love:

Full-frame, 21MP sensor
Going from a crop sensor to full-frame is a bit of a double-edged sword. The 1.6x crop factor is great when shooting with a long telephoto. You get extra reach, for “free.”

Full-frame depth-of-field, at f/4

On the other hand, that crop factor makes your “standard” focal-length 50mm lens more like 80mm, which was a bummer in close quarters.

So, I gave up some reach. But the full-frame 5DMKII gave me something better (in my opinion): shallower depth-of-field. Since the 5DMKII’s sensor is nearly twice the size of the 40D, f/4 really looks like f/2.8 used to, and so on.

21MP also gives me a lot of room for cropping. I could literally throw half an image away and still be at the 40D’s resolution.

ISO/noise performance

ISO1600

Due to it’s physically larger sensor size (and technology improvements, of course) the ISO performance is easily a stop (sometimes two) better than the 40D. ISO800 on the 5DMKII looked a lot like ISO400 on my 40D, and I’m not at all afraid to push to ISO1600 when needed.

When paired with a fast prime like the 50mm 1.4 and you can just about see in the dark. Literally.

LCD screen
The 5DMKII’s LCD is big and bright, and actually has enough resolution to be useful for checking focus, especially when shooting in situations when the depth-of-field is very shallow.

Not so much anymore

Dated auto-focus mechanism
The 5DMKII’s auto-focus mechanism is pretty much a hold over from the original 5D (introduced in 2005). The biggest hinderance is that the 9 auto-focus points are very tightly-grouped to the center of the 5D’s enormous full-frame. There just isn’t enough frame coverage. (BTW, I know that Alex is saying “I told you so” right now).

5D Mark II view finder	40D view finder

The lack of frame coverage isn’t a problem for me in terms of framing (or getting) a shot. I’ve adjusted to that. The bigger issue for me is metering. The 40D and 5DMKII have pretty much the same physical arrangement of auto-focus points, giving the 40D the edge on frame coverage when it comes to metering.

Because of the dispersal of auto-focus points, using “evaluative” metering on the 40D takes into account a majority of the frame, while the 5DMII only covers a small amount. This causes the 5DMKII to meter very differently from the 40D. Out of the box I was getting shots that were consistently 1/3 - 2/3 stops underexposed, especially when shooting with my 580EX II.

My complaints about the AF also extend to the HD video operations of the camera. There is no continuous AF, a feature that every other video camera sold in the last 15 years (or more) has. It does have slick features like face detection, but you still have to press the AF-ON button to grab focus, which will you’ll hear in your video.

Sluggish operation and response
The 40D is like a Ferrari when compared to the 5DMKII. There was almost no shutter-release lag in the 40D, and the frame blackout was very short. The 40D was also seriously fast in high-speed mode.

The 5DMKII’s shutter release feels very “squishy” to me (as did the original 5D). I suspect that it’s due to the large shutter/mirror assembly of the the 5DMKII, more than electronics and processing power.

Verdict?

Do I regret buying the 5DMKII? No freaking way.

It’s awesome, amazing, and astonishing. My complaints about the AF layout and sluggishness aren’t deal breakers, and aren’t issues in may day to day use of the camera. The quality of the images it produces continually put a smile on my face. You’ll have to drop $6,500 on a 1D Mark III to get (marginally) better image quality.

I do wonder why Canon made the decision not to overhaul the AF system on the 5DMKII, especially when considering it’s closest competitor, the Nikon D700 is superior in just about every way (there, I said it). I spent a few minutes with Will’s D700 a few months back and was blown away by it’s build quality, view finder, AF performance, and built-in wireless flash system (of which, Nikon’s have had for years). I know Canon is paying attention, just look at the new 7D.

5D Mark II samples:

Find it interesting? Have a topic we should be discussing? Contact us in the comments on the podcast’s web site (http://improvingpodcasts.com) or send e-mail to feedback at improvingpodcasts.com.

Topics:

- Snow Leopard Features
- Snow Leopard and Win 7 compared
- Windows 7 Features

Links to sources:

Snow Leopard
- Photoshop problems: http://kb2.adobe.com/cps/512/cpsid_51229.html
- Apple’s info on SL changes: http://www.apple.com/macosx/refinements/
- A bit of detail on the services menu changes and how to take advantage of them: http://www.macosxautomation.com/services/
- A very long Ars Technica review of SL: http://arstechnica.com/apple/reviews/2009/08/mac-os-x-10-6.ars

Windows 7
- MS’s feature list: http://windows.microsoft.com/en-US/windows7/products/features
- Notes on enterprise adoption (BitLocker info): http://searchenterprisedesktop.techtarget.com/news/article/0,289142,sid192_gci1360566,00.html
- Info on video memory: http://www.techarp.com/showarticle.aspx?artno=645&pgno=3
- A (somewhat old) article on backward compatibility promises: http://gizmodo.com/5070219/giz-explains-why-windows-7-will-smash-vista

Contacts:

- Leo: http://improvingworks.com
- Mike A. (@mikeabney): http://practicallyagile.com
- Allen (@allenhurst): http://ahurst.com

- Defining modularity
- Publishing Modular Java
- Describing OSGi and Spring-DM
- Answering complaints about OSGi complexity
- Differences in OSGi containers
- Benefits and pitfalls of OSGi in practice
- How Spring-DM is affecting the evolution of OSGi
- What is new in Spring

Craig’s picks:

- http://twitter.com/veryshortstory
- Ops4J Pax Construct: http://wiki.ops4j.org/display/paxconstruct/Pax+Construct
- Spring Expression Language: http://springsource.org

Leo’s pick: Google Web Toolkit: http://code.google.com/webtoolkit/

Mike’s pick: functional programming

- Introductory article: http://www.defmacro.org/ramblings/fp.html
- Scala (runs on JVM): http://www.scala-lang.org/
- Erlang: http://erlang.org/

Contacts

- Craig (@habuma, @modularjava, @springinaction): http://jroller.com/habuma, http://modularjava.com, http://springinaction.com
- Leo: http://improvingworks.com
- Mike (@mikeabney): http://practicallyagile.com

You can provide feedback for this and other episodes through comments at http://improvingpodcasts.com, via email to feedback at improvingpodcasts.com. Reviews and ratings in iTunes are welcome as well (especially positive ones).

I mentioned in my first post that we were using interfaces to represent our models and WHY we did it. So here’s the HOW of doing it.

Binding

As I mentioned, we used the model attribute to decorate our models when they are in the method signature. This attribute was based on the AbstractParameterBinderAttribute from MvcContrib (if you’re using ASP.NET MVC and NOT using MvcContrib, you’re probably re-inventing more than a few wheels) which is just a CustomModelBinderAttribute with a little bit of happy sprinkled in. Here’s what our binding looked like:

public override object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
{ ViewDataDictionary viewData = GetViewData(controllerContext.Controller); object result = null; if (viewData != null) { result = viewData.For(controllerContext, bindingContext); SetViewData(result, controllerContext, bindingContext, viewData); } return result;
}

The GetViewData and SetViewData are pretty self-explanatory but the real heavy lifting is in that extension method. Let’s take a look at it.

DictionaryAdapter

We know that we have a giant dictionary holding on to our data and tedious mapping using strings make me itchy, not to mention it breaking my refactoring tool, so how do we push the values without them? DictionaryAdapter from Castle. This little known, under utilized piece of work was shown to me by Craig Neuwirt, it’s creator, and I’m constantly amazed at it’s usefulness. Observe the following extension method for ViewData:

private static readonly IDictionaryAdapterFactory ViewDataFactory = new DictionaryAdapterFactory(); public static object For(this ViewDataDictionary viewData, ControllerContext controllerContext, ModelBindingContext bindingContext)
{ ViewDataAdapter data = new ViewDataAdapter(viewData); object adapter = ViewDataFactory.GetAdapter(bindingContext.ModelType, data); IDictionaryAdapter meta = adapter as IDictionaryAdapter; meta.FetchProperties(); return adapter;
}

It’s that simple. No, really. The DictionaryAdapter will match up the properties on the interface you defined with the corresponding elements in the ViewData and push their values into an instance of the model. All of that, without you even having to buy it dinner.

There’s more??

This approach worked great for us and gave us most of what we needed, however, this code doesn’t handle rehydrating objects from ActiveRecord – yet. But that’s a post for another night…

CORRECTION: Craig informed me that he did not create it originally but re-wrote it’s initial implementation to what it is now. Sorry for the misunderstanding.

David O’Hara is a Principal with Improving Enterprises in Dallas, Texas.

Improving is number 120 overall and number 8 in all of IT!

Improving is also #2 in the Dallas/Fort Worth area.  Ironically, the #1 in DFW is my old employer, One Technologies, who these days is an Improving Client.  They are totally rocking with a national ranking of 8.  Congrats to our good friends at One Tech!  It looks like last year they were #210.  Can they keep climbing?  Maybe together we can move up the ranks.

To commemorate the occasion, I want to tell a little story about how Improving came to be, at least from my perspective.  Everyone involved has a different angle, so hopefully others will comment or blog their own experience to add to the story.

In 1993, I was in the contract programming business and ran across this crazy English bloke named Graham Glass who was a co-founder of ObjectSpace and ended up becoming my close friend and mentor in iterative/incremental software development using object-oriented concepts.  In 1994, I joined ObjectSpace as a very young senior consultant and my first large consulting gig was with E-Systems on the Commercial Remote Sensing System (CRSS) project, building a global satellite imaging system.  On that project, I worked with the best manager I’ve ever encountered, Barry Rogers, and a few newly graduated software developers, including one who always wore a suit and was driven towards greater things named Curtis Hite. 

In 1995 after Raytheon acquired E-Systems and I had spent a year and a half with the CRSS team, I left the project to do a variety of other things and the superior group of engineers went on to become internal consultants within Raytheon across many projects.  At the same time, ObjectSpace started its bootcamp program to hire aspiring object technologists with great potential and to train them in “the ObjectSpace way”.  Jef Newsom was one of the first and most gifted students of the internal bootcamps and graduated to become an excellent instructor.  In 1996, the adventurous Jef moved to Washington D.C. to be a part of ObjectSpace’s first satellite office and in 1997 I worked on a project in D.C. for about 6 mos, where Jef and I became fast friends, bonding over software & skateboarding, billiards & beer, and jokes about Texans. 

In 1998 the Raytheon team, frustrated with the ability-agnostic pay structures of government contractors, looked around for another place to land.  ObjectSpace couldn’t hire them because they were client personnel, so they joined a newly forming company called Expeed which eventually became the North American branch of Valtech.  Also in ‘98, Jef left ObjectSpace for another entrepreneurial adventure in Dallas and in 1999 I left for one in northern Virginia, as well.  In 2000, ObjectSpace was facing trouble and sold its training division, with Ken Howard and Diana Hoogland as heads of operations and sales, respectively, to Curtis, Barry, and the gang at Valtech. 

Jumping ahead a few years to 2003, Jef was consulting on a project in the social networking space where they wanted a like-minded person to head up the development team.  I took the job and moved back to Dallas to get schooled by Jef in .NET architecture and C# development.  Meanwhile, Valtech was going strong with the leadership of Curtis, Barry, and Ric DeAnda, with many other great people in the ranks.  In early 2004, my social networking company ran into financial problems just as we were growing a user base, so we shut down that line of business and I started making plans to move on.  Jef was doing independent consulting elsewhere at the time and looking for the next big thing.  When I told him that I was ready to leave and start something new, he asked “Do you want to start a company together?”  Without even knowing what we would do, I blurted out “Yes!”  We started planning and working toward incorporation and signed the papers on August 15th, 2004 for Improving Enterprises, LLC. 

We began as a consulting and training firm specializing in .NET development and applying our valuable experience in object-oriented, agile development from the Java world.  We started as a registered Microsoft partner, and through years of hard work and earning a long list of customer references, became Microsoft Certified and eventually a Microsoft Gold Certified Partner for both Learning Solutions and Custom Development Solutions. 

In 2006, the international leadership of Valtech, suffering an extremely severe case of rectal-cranial inversion, decided they didn’t like the profitable direction of the North American branch, and systematically pushed out the entire leadership and sales teams.  The leadership team, composed of former CRSS and ObjectSpace team members, formed a new think-tank called The Blue Ocean Group, which in early 2007 Jef and I convinced to join forces with us to form the stronger, faster, and healthier Improving Enterprises, Inc.  We now have many people from the original Raytheon CRSS team and from ObjectSpace, as well as many other talented and excellence-focused people from the software development industry in our area.  On this special occasion, thanks go to everyone for making this company more capable and self-sustaining than we dared imagine in the beginning.  It’s a pleasure to work with everyone in the company and to continue to experience the great success that we have been fortunate enough to enjoy up to this point.  Thanks also go to our customers and partners who give us fun and challenging work to do.  We plan to continue bringing great business value and the spirit of improving to everything we do, for many years to come. 

As you know, PDC is the premier conference for .NET developers in the world.  We’re fortunate enough to have it two years in a row because of all the great new technologies growing around the .NET platform.  So if you missed it last year, you should definitely make it this year.  And, you can save $500 by registering before September 15th. Come on out for the conference and make sure you get there a day early to join us on Monday for this valuable pre-con! 

What a bunch of spoiled brats! But hold on…the terms of the contract rider were NOT actually demanded by the band members. David Lee Roth explained that Van Halen concerts had extensive technical and engineering requirements that must be followed explicitly for safety reasons as well as to ensure that the show could go on with no surprises. All of the site preparation details were meticulously laid out in a contract rider. The rider spelled out everything that must be done to prepare the stage, sound equipment, lighting, etc.

Hidden way down in the nooks and crannies of all these instructions was the “No Brown M&M’s” requirement. When the band showed up for a performance, if there were no M&M’s, or if they were there and the brown ones weren’t removed, it set off a red flag that the contract had not been read carefully. The show would be delayed until every detail of a site preparation could be verified. When telling this story on This American Life, Ira Glass referred to this as a “Canary in the Coal Mine”.

This story illustrates the great challenge with written requirements. When requirements are written down, the burden of fulfillment then lies in the hands of the person reading the requirements, and it’s highly probable that requirements will be missed. The “Canary in the Coal Mine” is a clever trick to ensure that written requirements are carefully handled, but it’s not attacking the heart of the problem.

Effective, real time communication is the key to quality requirements handling. This is why most Agile practices emphasize high bandwidth communication over writing things down. It’s possible that the use of passive communication techniques such as filling out business requirements documents may not be avoidable, but when these techniques are used, you may want to embed a canary…