I know there has been a lot of frustration over the last year as we have been working on zVision, the web platform, and ReEn. The shift we are making takes us from creating products to the creation of a platform.

So far, most have only felt the pain of the transition and have not seen the advantages. I promise you that this transition will be worth the pain and frustration. We are on the cusp of realizing a payout and it will be huge!

A guy who worked at Amazon and is currently at Google recently posted what was intended to be an internal memo on this topic. Everyone should take time to study the attached memo (http://steverant.pen.io) and understand the points that are made.

Here are a couple of threads where people are discussing Stevey’s memo that you may find useful:

• https://plus.google.com/112678702228711889851/posts/eVeouesvaVX
• http://www.reddit.com/r/programming/comments/l9ehj/steves_google_platform_rant/

I will continue to do everything I can to clearly communicate the amazing direction we are headed.

• zVision puts us at the forefront of the technology industry!
• zVision is the platform we need to carry us for the next 10+ years!
• zVision will give SRS the flexibility and agility to dominate in our chosen market!

You are welcome to send me questions or comments privately. Alternatively, I have cross-posted this to my blog and you are also welcome to publically comment there.

• http://blog.zobie.com

- Nate

Nate Zobrist | VP of Software Architecture
Service Repair Solutions, Inc. — Revolutionizing the Delivery of Service and Repair™

770 East Technology Avenue, Building F | Orem, Utah 84097
Phone: (801) 437-5846 | Fax: (801) 437-5899 | Cell: (801) 788-4789
www.servicerepairsolutions.com

An interesting analogy that was made compares applications to swiss army knives. The analogy is relevant to SRS and provides a great visual depiction of the work we are doing as part of our SaaS and SRSWP initiatives.

Historically our applications were designed as large, monolithic beasts. Like this knife, every feature that could be imagined was rolled into one of our flagship products. This design meant:

• Duplicated effort because there were no shared components between product lines.
• Intense effort required to join the team due to the large, interconnected designs.
• Even small changes were risky and had the potential of destabilizing anentire product.
• Management of each product line required enormous effort to tightly coordinate development and release of new features.

Contrast that complexity with a design where:

• Components are small, independent apps that work together (like Linux tools).
• Each component delivers specific functionality.
• Touch points between components arewell-defined contracts.

The workflow enabled by this component-based architecture is truly liberating.

• Small teams (perhaps even a single-person team) can build on top of the shared platform to quickly create new products.
  • Most products do not need to worry about operational infrastructure, databases, etc.
  • Products can take advantage of shared services to quickly enable powerful features in innovative ways.
  • Products can tap into shared repositories of both customer-generated and catalog data.
• Existing products are simpler to maintain and introducing change is far less risky.
  • A smaller codebase means that the project is much easier to grok.
  • Well-defined contracts that have robust automated tests written against them mean that each component can be released independently with confidence.
• Teams can work more efficiently by choosing technologies and frameworks that are tailored to fit specific needs.
  • Using standards-compliant web services for an API means that apps written in Java, Ruby on Rails or Node.js can access shared services as easily as a legacy, .NET application.

Following a component-based approach will make the creation of new apps a trivial exercise. It will free us to focus on solving interesting problems rather than being bogged down by operational overhead. The quality of our offering will increase as we become much more responsive to customers.

Applying these principles means something different for each of our existing projects and teams. What remains to be done for your team to fully benefit from this component-based design? What new functionality would you like to see exposed by the SRSWP?

Let's say I want to write an app that integrates with the del.icio.us bookmarking service. My application will be reliant on their public API. So, for this venture to be successful:

The API's Contract Definition is essential:

• Method descriptions, examples, limitations and assumptions are all necessary and are included as part of the API documentation.

The API's Contract Stability is essential:

• Breaking changes should be very rare. Even with a disclaimer stating that it may change at any time, there is an implied level of stability in any published API.
• When a breaking change to the API is necessary, backwards compatibility will be provided. That's why their APIs all have "v1" in them!

Within SRS we should think about cross-project integration similarly to integrating with external services like del.icio.us. Except in very rare situations, touch points between products are limited to APIs (i.e. massively-versioned web services).

When I referred to "absence of trust" in zVision, I call attention to the fact that we do not yet have the requisite level of Contract Definition and Contract Stability in our APIs. Without both definition and stability, I could not trust the del.icio.us API enough to base my app on it. The same is true for building on SRS-internally produced services.

Since the end of 2010 and through 2012 we are making a large investment in re-architecting our products based on principles of SOA and SaaS. Absolutely essential to success are APIs which are both well defined and stable. Once we have those things, we can trust the services provided by other SRS teams as much as we would trust del.icio.us.

Source Code Management

Source control is a fundamental part of software development. The benefits of using a source control management (SCM) system are numerous and worthy of their own blog post. But, I have noticed two significant problems with the way that SCM is currently being used on many of our projects:

1. ChangeSets are frequently too large
2. ChangeSets often contain code that shouldn't be committed

ChangeSets Are Too Large

I am frequently guilty of working for days on a particular task without committing any changes to source control. I like to wait until my task is completed. I don't want to break the build, and I don't want to commit broken code that might impede others. But, the biggest reason that I avoid committing my working code is that I don't want anyone to see it until I'm finished.

There are several problems with monolithic commits, including:

• Integration headaches: large ChangeSets increase the odds that changes will conflict with someone else's changes
• Useless file history: comments on large ChangeSets are, of necessity, more vague and less likely to convey useful information

My preferred version control software at the moment is a DVCS. DVCSs offer many benefits over traditional SCMs, but one of the best is easy branching and merging. A DVCS allows me to work like this:

Branch per Task

Every development task is a new, independent branch. Tasks are merged into the permanent main branch as they are completed.

(from Coding Horror)

Each time I am ready to begin a new task I create a branch for all work on that task. I generally have several active working branches that I can easily switch between. I check in code often to my working branch, rarely going more than a few hours between commits. Once I have finished working on a particular task, I merge my completed code back into the shared master branch. I am able to make frequent commits without breaking the master branch due to incomplete code.

Unfortunately, TFS does not easily support this style of development. Creating branches is inconvenient, and merging code between branches is torture. Although I would love to recommend that SRS adopt the style of development that I've described, I just don't believe that it is feasible with current versions of TFS. Given the painful nature of branching and merging in TFS, I don't see a better alternative to our current branch per-release strategy.

Given that TFS doesn't provide easy branching and merging, here's what we can do to find a happy medium. We should not check in broken code, but we shouldn't hesitate to check in code that is incomplete. Especially for new functionality, there shouldn't be any problem checking in a stub method that doesn't do anything. There are very few, if any, situations where we would be unable to commit our working code to TFS once a day.

There will no doubt be times where checking in small, granular ChangeSets will not be practical. There will be times when some of our tasks require us to break the application (not the build though!) in order to complete a task. However, it is my belief that with a little planning these times should be brief and infrequent.

It would be foolhardy to ignore the problems that accompany frequent check-ins. As the number of developers working in the same code base increases, so too does the probability that someone will check in something that will disrupt everyone else's work. This leads directly into my second topic: We must be aware of the code that we are checking in.

ChangeSets Contain Code They Shouldn't

When it is time to commit code to TFS, it is not uncommon for developers to simply check every file listed in VisualStudio's "Pending Changes" window and commit all outstanding changes. Although VisualStudio makes it incredibly easy to follow this bad practice (Why are all modified files checked by default?!?), we need to stop doing it. Sometimes debug code is committed and leads to problems that are only discovered after our customers have the release. Sometimes builds are broken as csproj and sln files are inadvertently modified. Sometimes it simply messes up the file's history (TFS always increments the version and updates the file's history, regardless of whether anything in the file has changed). These things should not happen. When checking code into SCM it is the developer's responsibility to verify every change that is being made. The developer should diff all changed files and verify every change that will be committed.

If anyone has found and enabled the option in VisualStudio to "Check in everything when closing a solution or project," please disable it immediately. No good can come from that option!

In some cases you may imagine that these procedures don't apply to you because you are the only developer on your team. That is a false assumption. Code should always be written for the long-term. Code should always be written and commented in such a way that another developer can pick up your tasks at any time. Julian Bucknall, the CTO of Developer Express, recently posted a thought to his blog that precisely expresses the point I am trying to make: Assume your code will be public. I am as guilty as anyone — probably more so, actually — of some of the bad practices that Mr. Bucknall describes. Edge Legacy is full of funny names and informal comments that I wrote to amuse myself. As we consider publishing more of our APIs for external consumption, it is increasingly important that the code we write properly represents the professional nature of SRS and increases the trust that our customers have in us.

See Also

• MSDN: Branching and Merging Primer
• Coding Horror: Check In Early, Check In Often

Getting TFS to use P4Merge isn't difficult but neither is it intuitive. For a merge operation P4Merge expects four files to exist:

1. the original, base file
2. file with conflicting change #1
3. file with conflicting change #2
4. final, merged file

Unfortunately TFS doesn't create the merged file (#4) until after the merge tool is invoked. A simple batch script will solve the problem though. Save this as p4merge.bat.

@ECHO OFF
COPY /Y NUL ""%4""
START /WAIT /D "C:\Program Files\Perforce\" p4merge.exe ""%1"" ""%2"" ""%3"" ""%4""

This script will create the merge file and invoke p4merge.exe.

Now you can configure TFS to use P4Merge by running this command from a Visual Studio command prompt: tf diff /configure

That will bring up a dialog:

If an entry already exists for the Merge operation you can add it. Otherwise just modify the existing entry to point to the batch file we created:

Note that you must set the command to be your batch file, not the executable.

And that's it! Next time TFS launches a merge tool, it will use P4Merge.

As a software version control system, I dislike TFS intensely.

In the short time I've been using TFS I've had several problems with code that was merged incorrectly. I've seen problems where TFS silently allowed older versions of code to overwrite newer versions. I could probably fill an entire blog post airing grievances with TFS but I thought it would be more interesting to describe how I use git on top of TFS to solve some of these problems.

First, to use git to track a TFS repository it is really important that all your source code be on a Fat32 partition. TFS locks files and NTFS respects that lock. Fat32 will track the lock but doesn't enforce it. This allows git to modify files (change to different versions of files) without necessarily having those files checked out in TFS.

Using TFS I checked out all my code into s:\src. I then created a new git repository in that same directory and added everything into the git repository.

For working I maintain at least two branches. My master branch always matches TFS. When I need the latest code from TFS I switch to the git master branch, pull from TFS then commit all changes into git. My working branch contains my current code changes. I also have one branch dev that contains a single commit consisting of all my debug code that should never be checked in to TFS.

When I'm ready to start coding I get the latest code from TFS and commit those changes into git's master branch. I create a new git branch, working. I cherry pick my development code from dev into working. Then I do all my coding on that branch. When I need to get code from TFS I can swtich to master, update from TFS, check that code in to git then either merge or rebase the changes back into working.

Once all of my changes in working are complete I need to merge the changes back into master so that I can commit them to TFS. I can't do a straight merge becuase my cherry-picked dev code would be included. So I have two ways of doing this:

1. cherry-pick changes from working, applying them to master
2. backout the development code (using git rebase -i) then merge changes back into master

After going through one of these two options I end up back on master with all of my code changes. I then commit the changes to TFS. Once that is done I delete working and recreate it from master next time I need it.

Working like this has been great for me. If there are conflicts when merging my code changes, git takes care of it. This way I can almost always avoid having to let TFS merge anything.

This is my general way of working but you can easily see how to apply these same principles when you want to work on multiple different changes using multiple different branches in git.

One thing to note: When you're working like this git's history isn't great. This isn't like git-svn where you get a seperate git revision for every svn revision. For me, using git with TFS isn't about being able to track my changes over time. I just want to make sure that my changes aren't lost and I don't want to clobber anyone else's changes.

WARNING: Gross generalizations and simplifications below. I'm not trying to offend anyone, just describe my experiences.

Most of the contract work I've done has been for people who are not technically savvy. They come to me with a very vague idea of the software they want. They expect me to tell them how much it will cost before we've discussed specific requirements. When the requirements are incomplete or incorrect they expect that I'll just fix it without additional cost to them.

Not all of my contract experience has been negative. In fact, most of it has worked out quite well. Usually both my client and myself are pleased with the software and the cost of building it. But I've had enough negative experiences to be careful when considering a new job.

Part of the problem is that it is nearly impossible for anyone to completely define the scope of a project. There is always some miscommunication or misunderstanding, there is always some unforseen problem.

"You want me to setup a blog for your company? No problem, I can get WordPress setup for you in an hour."

"Wait, I didn't realize that by 'blog' you meant store front application that can accept payments, handle accounts payable, accounts receivable and inventory tracking. That will take slightly more than an hour."

That kind of situation actually isn't bothersome to me. As a contractor it is part of my job to understand what you want before making a bid. If a potential client obviously doesn't know what they want, I can either decline to bid on that job or I can adjust my bid to account for a large amount of unknown. I don't love it, but that type of risk is manageable.

The part of contract work that I dislike is being forced to compromise quality. When I'm working on a fixed cost contract, it is in my best interest to deliver exactly what is specified, as quickly as possible. As long as my client is reasonably happy with the deliverable, I am going to get paid $20k regardless of whether it took two days, two weeks or two months to create. I don't get additional money for clean code. I don't get extra for having good test coverage.

When I complete a project more quickly than I had anticipated there is no problem. I can spend time verifying that the code is tight and that everything is working as expected. But if I am running behind schedule, it becomes more difficult to care about testing the code or fixing "little" bugs.

There may be a bug in the code where order totals aren't calculated correctly, but what are the odds that my client will notice the bug before he signs off on the project? If he does find the problem and I correct it, will he think to test for that same bug in every release?

This is the dilemma that makes contract work difficult for me. If I see a bug in my code, I'm going to fix it. If I'm writing a tricky or important calculation (like calculating totals), I'm going to write a test. I need to have confidence that my code is doing what I expect. I've never shipped any software that didn't have a list of known bugs but I have also never shipped any software in which I didn't have a high level of confidence that it was working correctly.

For me, doing the bare minimum isn't an option for two reasons:

1. Quality is extremely important to me. I can't just hack something together that meets the contract requirements. When I write software, I want to deliver my personal best.
2. Most of the time, the fast/crappy way of implementing something simply doesn't occur to me.

I understand a company's need to understand cost before approving custom softare. But if you want me to do contract work, pay me on an hourly basis. I'll give you a projected timeline for project completion.

With an hourly rate, you only pay me for the time I actually spend working. With an hourly rate I know that I won't lose money just because I insist on high-quality code. We'll both be happier in the long run.

The tools that I use for C#.NET are pretty standard:

• Microsoft Visual Studio 2008 (with ReSharper)
• SQL Server Management Studio
• .NET Memory Profiler to chase down memory leaks
• AQtime to help locate performance problems
• Outlook and Skype to stay connected to coworkers
• Team Foundation Server (TFS) for tracking work items and for version control
• cygwin to make the command line in Windows behave somewhat normally

The one thing that is sorta strange about how I do my C#.NET work is that I do everything on a Mac Pro with XP running in VMWare Fusion. I've had a similar setup at home for a couple of years but I've only had this setup at work since January.

There are definitely a few quirks that I had to get used to, working in Windows running in a VM on OS X. But the benefits of this setup far outweigh any inconvenience. The ability to take snapshots of the entire VM is awesome! If a program screws with my registry and Windows starts acting funky I just roll back to the last snapshot!

The other huge benefit to working in VMWare is memory. Unless you're using 64-bit Windows (which can be problematic for many reasons) you are limited to 2 GB of memory. Windows sucks at managing virtual memory so I always try to keep my open applications below that 2 GB limit. Since my Mac has 12 GB of memory, if I need to do something else, I can just boot up a second VM.

Most of the software that I've written for OS X has been personal projects. Nothing fancy, just various tools to scratch some itch. Since getting my iPhone I've been doing more work in Objective-C and Cocoa.

Because I've done so much work with managed and interpreted languages, it feels a little weird to work in unmanaged C/ObjC. But it is kinda cool too. Objective-C is a fairly simple language and Cocoa is a very nice framework. There are some things that I don't like about Obj-C (not having namespaces and gimpy string manipulation come immediately to mind) but I really appreciate being able to actually use Cocoa controls for UI work. It is almost unthinkable to do GUI development for Windows without buying a set of third-party controls.

My must-have software for writing Mac/iPhone applications:

• XCode and Interface Builder
• Instruments
• MacPorts to install all of the software that is missing from the base OS X install
• Mail.app, Syrinx, Adium and Colloquy to keep in touch with other developers

And finally, a few additional pieces of software that are invaluable to me. These are helpful regardless of what type of software I am writing.

• OmniFocus to help me Get Things Done
• git for source control (don't tell anyone but I keep my TFS repositories checked into git too)
• Terminal.app for a whole bunch of things
• PathFinder because Finder doesn't always cut it
• GeekTool to keep an eye on logs
• vim
• screen
• Photoshop
• iTunes to help keep me in The Zone!

When I'm working in Java I always prefer to use JetBrains' excellent IntelliJ IDEA. However, this past year I didn't have a license for IntelliJ. I tried every free IDE I could find and wound up choosing Eclipse. I've used Eclipse periodically over the last several years. I don't really like it but I dislike it less than the other free alternatives.

My work was completely server-side and didn't involve developing a database component. Most of my development was done on OS X but I was deploying to Ubuntu so I did work there also. I used maven to build, test and deploy. I'm not a unit-test fanatic but, in this case unit testing was invaluable.

My setup for both PHP and Python is the same. When I'm working on Mac I use either TextMate or vim. I haven't done a great deal of Python work but over the past several years I've tried to find a PHP IDE that I like... I'm still looking.

I started out doing my Ruby work using TextMate and Terminal.app. I didn't have any major complaints. There are some nice plugins and various tricks that are handy. But personally, I prefer an IDE. I've heard some people say that IDEs make us lazy. Ok, I'm lazy. But I'm also far more productive when I have a good IDE. When JetBrains started issung beta releases of RubyMine, TextMate was history!

RubyMine's GUI for easily stepping through code in the debugger is great. The inline code analysis is nice for quickly catching typos and the code completion can be useful too. But for me, the best part about having RubyMine is the navigation and documentation.

When I'm working with other developers (or even with frameworks that I didn't write), I don't always know exactly what a method does. Being able to instantly bring up documentation is awesome! If I need more information, I hate wasting time trying to hunt down a method buried in code that I am not familiar with. With one key-stroke RubyMine takes me to the code I'm looking for.

I am definitely a fan of JetBrains' production. IntelliJ is awesome, RubyMine is awesome, and VisualStudio is just broken without ReSharper. There is certainly a learning curve to these tools but once you've memorized the key strokes, the code you need is always right in front of you. And the best part part is that the key bindings are the same across each of JetBrain's products!

One last application that deserves to be mentioned is Navicat. Navicat is by far the best application that I've found for working with MySQL or PostgreSQL. Unfortunately, that's not saying much. I have spent a lot of time using SQL Server and Microsoft's related tools and, as far as I can tell, there is nothing for MySQL that is even in the same league.

Don't misunderstand me. Navicat is a great tool. Allowing me to save connections to different servers with many different login credentials is a lifesaver, especially the ability to tunnel the connections over ssh. Being able to do basic server management via a GUI is nice too. But when I need to design a database, I always turn back to SQL Server Management Studio.

When I first discovered Puzzle Master the running contest was:

To enter the contest, upload to our fan photo album, a screenshot of your desktop and development environment (including as many editors and tools as you can, and your desktop wallpaper) along with a short essay of 250 words or less explaining why and how you use it.

I don't generally participate in this type of contest but I always find it interesting to see how other developers work. There were some cool prizes available and not many entrants so I decided to upload a screenshot of my desktop.

I was disappointed because the picture was scaled down so much that the apps were indistinguishable. So, I decided that it might be fun to do a few posts on my development environments.

First up... my physical setup!

The picture is a link to flickr where I've attached some notes to the image.

• MacPro (2 x 2.66GHz Dual-core Xeon) with 8 GB and ~2.5 TB
• Two 24" Dell monitors, both at 1920x1200
• Mac OS X 10.5
• VMWare Fusion running XP SP3

This is my home office but my work setup is similar. At work my MacPro is 2 x 2.8 GHz Quad-core. It has 12 GB memory and a single 500 GB disk. Maybe I'll try to update this post later with a picture of my desk at work.

Update:
Here's my desk at work!