new ThoughtStream("Derick Bailey");

Theory Of Constraints: Productivity Metrics in Software Development

derick.bailey — Fri, 03 Jul 2009 17:38:16 GMT

In the past, I’ve been a true believer that software development is not really possible to measure from a productivity perspective. I was ignorant, basically. I’m now a bit wiser and I understand that software development is no different than any other product development process. We can and should measure productivity of software developers by understanding that we are building business value via functionality that the end-user wants. So, we should essentially be measuring our progress toward the end user facing functionality (as an over-simplification).

A Paper On The Theory Of Constraints

Several months ago, I wrote up a paper for an internal company effort to help define productivity metrics for software developers. This paper is largely based on the work of David J. Anderson, in “Agile Management For Software Engineering”. It also includes some of my own interpretations and understandings of the Theory of Constraints.

The original intent of this paper was to facilitate the discussion of productivity and metrics in the Development Department at McLane Advanced Technologies, LLC., where I work. I decided to release it to the world, to hopefully help others understand how we can measure productivity as software developers. I did not intend this to be a comprehensive or exhaustive discussion of the points within, but am trying to spur additional research and conversations. I hope you enjoy reading it as much as I enjoyed writing it.

Download The Paper

You can download the PDF here:

The Theory of Constraints: Productivity Metrics In Software Development

How To? Highly Complex Query Generating Based On Security Needs

derick.bailey — Thu, 25 Jun 2009 20:26:29 GMT

I have the following object model:

An Office belongs to one Office Group. An Office also belongs to one Office Region. There is no relationship between Office Group and Office Region. They are two separate groupings for various reasons. A Counselor belongs to one Office. A Veteran is assigned to one Office.

I need to implement the following security rules for a Counselor looking at Veterans, starting with “deny access to all Veteran records, unless any of the following are true”:

If a Counselor is an Administrator (a role of the Counselor), that Counselor can see all Veteran records
A Counselor can see any Veteran that has no current Office assignment
A Counselor can see Veterans that are assigned to an Office within the Counselor’s Office Group
If a Counselor belongs to a “Regional Office”, that Counselor can see Veterans that are assigned to that Region
… a few others in similar fashion …

I also need to implement the following around the above rules:

When a Counselor searches for Veterans, they are only allowed to see search results that meet the above criteria
When a Counselor views the detail of a Veteran, they are only allowed to see the the Veteran if the above criteria is met. This includes, if a Counselor tries to manually load a Veteran (manually type in url “id=1234”)

… and the Counselor is not allowed to see the Veteran, show a “Not Authorized” message
… and the Vet does not exist, show a “Vet Does Not Exist” message

so…

how do you create a search process around a security need like this? How do you go about creating a very complex rule system to determine which Veterans the Counselor can see? In my ideal world, I’d have some way of checking this security need against the search results and against an individual veteran record, without duplicating the code or logic for that check anywhere… is this a realistic expectation? What “standard” security implementations are out there, that would help me resolve my needs?

This is being done in C# in an ASP.NET Webforms app, using NHibernate for our ORM. I don’t expect NHibernate to be able to solve this problem for us, but if it can, that’s even better. And, I do expect to be able to write some sort of Unit or Integration tests around whatever the process is.

Any advice or help is appreciated.

Cloning Or Converting Linux VM From VMWare Workstation To ESX Server: ETH0 Gone. ETH1 Available?

derick.bailey — Sat, 20 Jun 2009 18:57:01 GMT

I ran into a fun situation yesterday. I downloaded a virtual appliance for the Agilo Trac Plugin (which, if you’re a Trac user and trying to do sprints or iterations with it, you need to get this. It’s free and it rocks.) Turns out this VM is a Debian distribution. (I’m certainly no linux guru, but I can usually find my way around.)

Starting up the VM on my local VMWare Workstation worked fine. The distro is configured for DHCP, and my VM network bridged to my box, found the company network and found an IP for the VM. You can see the IP show up in the screen shot below:

After playing with the Agilo app for a few minutes, I wanted to share it with my coworkers and get their opinions. Fortunately for me, I’ve been helping the company grow a rather nice VMWare ESX Server infrastructure for our development needs. So, I thought the easy thing to do would be to migrate the VM up to a server and make it available.

I go through the “Export” process from VMWare Workstation and send it up to a server with no problems. I configured a static IP address in the /etc/network/interfaces file, as described in this article. However, when I get the server based VM up and running again, I run into a problem:

Note the first error circled: “eth0: error fetching interface information: Device not found”. And the second error circled: no ip address!!! That’s not good… how am I supposed to get to the box without an IP address… so, I check the network adapters through ifconfig to see if I can get eth0 back up.

No luck - “eth0: ERROR while getting interface flags: No such device”

Checking ifconfig, i see that there’s only an “eth1” configured in the vm.

After some serious hair-pulling-out frustration, several coworkers not having any clue, and a general sense of doom and gloom; I managed to pull some serious google-fu out, and found this post. The information provided looked like what I needed:

either

- the kernel in Lenny is newer and has a driver that is missing (or not
fully functional for your hardware) on the other system

or

- the new card was assigned eth1 because the previous card's mac address
is still listed in the database of persistent ethernet device names

Boot the problematic system and run "/sbin/ifconfig". If you see the
3Com NIC listed as eth1 then you can edit the file

/etc/udev/rules.d/70-persistent-net.rules

to assign eth0 to it. (Remove or comment out the entry for the old NIC.)

As it turned out, the conversion process from local VMWare workstation up to VMWare ESX Server caused the virtual NIC’s MAC Address to change. So I go hunting for the file they talk about, and it’s not there. Fortunately, it was only a few characters off from my debian box:

/etc/udev/rules.d/z25-persistent-net.rules

looking at the contents of this file, I found the system’s configuration for all of the network adapters, and noticed that there are two of them in my file:

but I know that the VM only has one virtual NIC. so, following the advice from the post above, I comment out the current “eth0” and rename “eth1” to “eth0”.

Reboot the box and it works!

A Kanban Is Just A Signal To Do Work

derick.bailey — Thu, 18 Jun 2009 21:10:03 GMT

A kanban is a signal to do something. I don’t think kanban implies a pull-based system, honestly. Joe Ocampo showed it best in his Scrumban presentation at Austin Code Camp:

That’s not a signal to pull anything… it’s a signal to RUN FOR YOUR LIFE!!! :) Now, having said that – I do think that a pull-based system is facilitated by kanban.

A Simple Kanban Enabled, Pull-Based Workflow

In a pull-based system, a kanban is used to signal the upstream process of the downstream needs. As an example, let’s look at a simple 2-step process.

Step 1 produces 10 parts and moves them into the “DONE” queue, saying that they are ready to be used by the next step.

Step 2 then uses 5 of those parts by pulling them out of Step 1’s “DONE” queue.

When Step 2 pulls those 5 parts out, the person doing Step 2 will signal Step 1 to make more parts. That is, they send a kanban back to Step 1, telling Step 1 that more parts need to be produced. This kanban may be a card, an email, a tap-on-the-shoulder, or any other mechanism that anyone can think of, to tell the previous step that work needs to be done.

When Step 2 is done, the parts can be put into the next queue. Step 2 then pulls the next set of parts out of Step 1’s “DONE” queue, and the cycle starts over…

To properly understand the flow of work in this diagram, read from right to left:

Finished work put into Step 2’s “done” queue
Next set of available parts pulled into Step 2
Step 2 signals Step 1 that work needs to be done
Finished parts pulled from Step 1 into Step 1 “done” queue
Repeat from #1

A Task Card Is Not A Kanban

I was involved in a project that ended a few months ago, where we did some experimenting with a pull-based, kanban-enabled workflow. The following picture is what our process looked like and was a direct outcome of the research and learning that went into my previous Kanban In Software Development posts.

(Note: Please disregard the glaring problems with this board. It was a learning experience for me and my team. :) )

Our kanban – our signal for an upstream process to provide more input for the downstream process - was not the task cards that moved across the board. In fact, I think calling a task card (a user story, an MMF, a function point, or whatever it is) a kanban is a serious misrepresentation of kanban. The task cards are exactly that – task cards. They are the work to be done, the work in process, and the inventory in queues.

My Team’s Kanban: Nothing

For my team, the signal to do more work was an empty stikki clip.

That empty slot in the “System Test” column was a signal to the testers that they could pull another task from the upstream process. The empty slot in “In Dev” was a signal to pull from their upstream. And the empty slot in “Analysis & Estimation” … you get the idea, right?

Kanban vs kanban

A kanban is just a signal for work to be done. It doesn’t have to be a “kanban card”. It doesn’t have to be any thing, actually – it may be the absence of something, as was the case in that project. In the end, I think the idea of calling that project’s board a “kanban board” was a misrepresentation of kanban. Additionally, there’s some interesting banter going around the blogs on kanban as a tool, more than just a tool, kanban vs “Kaban” (capital K), and how the software industry has branded a pull-based, signal-enabled workflow system as capital-K “Kanban” (and I can’t help but think that I contributed to this situation). So, maybe I can call this a “Kanban” board… but just because I can, doesn’t mean I should.

I’m Presenting SOLID At North Dallas .NET (NDDNUG), July 8th

derick.bailey — Wed, 17 Jun 2009 21:24:23 GMT

On Wednesday, July 8th, I’m scheduled to give my SOLID presentation at NDDNUG, up in Plano, TX. I don’t know if anyone up there remembers me, but NDDNUG was the first user group that I ever went to. I worked in Richardson, TX, for more than 4 years, just off Collins & 75, half a block away from NerdBooks. I’m excited to be able to return to my old stomping ground and do a presentation in front of the first professional software developer group that I was a part of, 6+ years ago!

The Presentation Materials

If anyone is interested in obtaining the slide deck and code for this presentation, I recently updated the .zip package in my media section, with the latest version of the slides.

Download The Presentation Slides And Code Here: http://www.lostechies.com/media/p/5415.aspx

The Presentation Abstract

Almost every professional software developer understands the academic definitions of Coupling, Cohesion, and Encapsulation. However, many of us do not understand how to actually achieve Low Coupling, High Cohesion, and strong Encapsulation, as prescribed. Fortunately, there are a set of stepping stones that we can use to reach these end goals, giving us a clear cut path to software that is easier to read, easier to understand, and easier to change. This presentation will define not only the three object oriented goals, but also the five S.O.L.I.D. principle that lead us there, while walking through a sample application.

The Impact of Staffing Practices on Software Quality and Productivity

derick.bailey — Sun, 07 Jun 2009 23:59:55 GMT

A Junior-Heavy Organization

Companies tend to staff various teams with an experience level of employees that have a very junior heavy bias. That is, for every person with senior level experience in the organization, there tend to be multiple mid level persons. And, for every mid level person, there tend to be multiple junior level persons. The end result is that we create an organization that resembles a hierarchy such as Figure 1.

Figure 1. Junior-Heavy Hierarchy

One of the key factors to understanding this hierarchy is to recognize that a person may be capable of working at a senior level in spite of a relatively short career. It is also likely that an individual in an organization may be considered senior level only by years in the industry or pay level, while that individual may not be able to work in a senior level capacity. Given these factors, an honest analysis of the company is likely to show many department hierarchies that are similar to the one outlined here.

There are many different reasons for staffing an organization in this manner. It may not be possible to find talented, senior level persons when a company is in a position to hire. There may be labor cost considerations, such as a desire to reduce the labor rates of a project resulting in a lower-cost proposal. Furthermore, it is often easier to teach inexperienced persons how to work according to a team or company standard, since they do not come with years of experience working in other manners. No matter the actual reasons, though, a department structure such as this is likely to have a significant and negative impact on the productivity and quality of the work done by that department.

Once a team begins to formalize around a junior heavy structure, there are a number of issues that begin to arise.

“As new products grow, revenues grow, the R&D budget grows, and engineering and research staff grows. Eventually, this burgeoning technical staff becomes increasingly complex and difficult to manage. The management burden often falls on senior engineers, who in turn have less time to spend on engineering. Diverting the most experienced engineers from engineering to management results in longer product development times, which slow down the introduction of new products.”

- Peter M. Senge, “The Fifth Discipline”, p. 96

Technical Leadership vs. Project Management

In a software development organization such as ours, there is a distinction between technical leadership versus project management. Technical leadership includes activities such as high level systems design and architecture, implementation details such as frameworks, tools and development techniques, and ensuring that the team is up to speed on the team standards and following those standards. In order to facilitate technical leadership in a team, the person tasked with this role will need to be involved in both the implementation of the system, as well as conversations on the system definition and requirements. However, the role of the technical leader should be to focus on the technical aspects of the system, ensuring consistency and stability of the system while meeting the business needs. It should also be noted that the senior level persons on a team are the appropriate persons for this type of work. They have the necessary experience and design capabilities, and should be adept at communicating decisions and technical directions to the rest of the technical team, effectively.

From a functionality standpoint, the project manager coordinates the high-level requirements and work organization with the customer, helping to prioritize the order in which those features need to be implemented. The prioritization of work is correlated with the assignment of work to be done by the functional groups. For example, the feature with the highest priority will be handed to the various functional teams: “Testers, go write scenarios for this, now,” and “Developers, go architect and build that, next,” etc.

At the functional group level, a technical lead (dev lead, test lead, etc) would help to break down the features and user stories into individual work tasks, and help to prioritize the order in which those tasks should be done. This is needed to facilitate the implementation needs of the system. At this point, the team members doing the actual work are to be given the authority to grab the next available task from the list, whenever they are freed up from their current task. In situations where individual tasks for a story have a similar or same priority (for example, if it doesn’t matter that screen/workflow X is done before or after screen/workflow Y), then the person who needs work is free to choose which task to take on next.

Unfortunately, senior level engineers often end up doing project management work instead of technical leadership work, when a team is structured in a junior heavy manner. This includes activities that do overlap the technical leadership role, to an extent. For example, the project management role includes definition and discussion of the system and requirements. However, the project management role also includes additional responsibilities that fall outside of the technical leadership role, such as maintaining project status and visibility or determining work to be done by functional groups. The project management role must account for the needs of project team members that are not directly involved in the implementation, as well. Persons such as technical writers, business analysts, testers and others, including the technical staff, need to have consistency of project management to ensure that the entire system is moving forward correctly.

Cycles of Decreasing Productivity

In Figure 2, there are two cycles of increasing momentum at play, which ultimately lead to the same conclusion – lowered productivity of the team. When the senior engineers in this scenario begin to have their time taken up with management tasks and meetings, there are additional side effects that lead to poor quality and unhappy customers.

Figure 2. Increasing Cycles of Lowered Productivity

As hiring is done, it is focused on mid and junior level personnel, for the various reasons previously discussed. This causes an obvious growth in the team, increasing the need for management structure and overhead in the team. Most often, the senior level persons on the team will fulfill this need. They are the most qualified individuals to do the training, and are able to help organize, direct, and assist the new hires and existing team members.

With the senior level persons’ time taken up with management tasks, they no longer have time to perform the high level designs and architectures for the team efforts. This leaves the mid level persons to the designs and architecture, when they may not have the experience and understanding necessary to complete these tasks. The burden of learning through trial and error of implementation can quickly become overwhelming, and the mid level persons will often spend an inordinate amount of time working on these tasks. When this occurs, the junior level team members will do the majority of the implementation work, in spite of being the least capable and least well equipped for the job. This ultimately leads to lowered productivity of the team, as the junior level members struggle with implementation details and technology questions that they cannot answer or get quick answers to. The lowered productivity of a team often leads to a desire to increase the staff, to boost productivity. However, only mid and junior level personnel are hired and the cycle begins again, causing additional delays.

The second cycle depicted shows how the lowered productivity of the team will lead to longer delays for customers to receive the end product. This often leads to unhappy customers, wondering why they must wait. When the management structure of the team hears about the unhappy customers, they often push the team harder, to try and increase productivity. Unfortunately, this usually comes at the cost of lowering standards and cutting corners. The individuals doing the work, at mid and junior levels of experience, may not have an adequate knowledge or understanding of the standards, or simply may not be able to maintain the standards without significant guidance from the senior level persons, who are not available on a regular basis. The drop in standards will eventually create a drop in the quality of the product, which inevitably leads to defects being found in the end product. The defective parts of the product are either delivered as-is, or immediately reworked to correct the issues, resulting in a still longer lead time for the delivery of the product. The result is again, a lowered productivity of the team as they deal with the issues that they are introducing into the system, and this secondary cycle begins again, resulting in customers that are less and less satisfied.

Combating the Issues

Figure 3. Senior Heavy Structure

Fortunately, there are ways to mitigate the issues described. To start with, teams should not be created with junior heavy structures. Rather, a senior heavy structure is desirable, as shown in Figure 3. This structure allows for the necessary promotion of senior level persons, into management roles and responsibilities. Assuming that the senior level persons have the necessary people skills for management and leadership, they are the most qualified persons to lead the teams in question. With such a structure, though, the teams are not left with a missing portion of technical leadership, implementation, and training needs. When one or two senior level persons are required to perform management tasks or attend meetings, there are additional senior level members available to handle the work load of that experience level.

Additional benefits can also be realized through a structure such as this. For example, it is widely believed that there are productivity gains of 10 to 20 times, or more, for senior level software developers vs. junior level software developers.

“The original study that showed huge variations in individual programming productivity was conducted in the late 1960s by Sackman, Erikson, and Grant (1968). They studied professional programmers with an average of 7 years' experience and found that the ratio of initial coding time between the best and worst programmers was about 20 to 1, the ratio of debugging times over 25 to 1, of program size 5 to 1, and of program execution speed about 10 to 1. They found no relationship between a programmer's amount of experience and code quality or productivity.”

- Steve McConnell, “Code Complete 2^nd Edition”, p. 682

Such productivity gains should immediately result in lower cost and shorter lead times. The experience and capabilities of the senior level personnel should also reduce the number of defects that are introduced into the product, improving quality and again reducing the lead time for delivery of the product.

Recognizing Reality

There are likely other benefits that can be attributed directly to the capabilities of a senior heavy team structure, as well. However, there are no silver bullets for anything in the real world. Simply having a team structured with a high number of seniors does not ensure that the work will be of high quality, or that they will be significantly more productive. Additional factors such as empowering the employees, focusing them with short term objectives that move toward long term goals, and a culture of open communication are also necessary. Fortunately, truly senior level persons should be able to facilitate the additional needs of the culture and environment. And in the end the time to delivery, product quality, and ultimately customer satisfaction should be sufficient motivation to begin ensuring a proper team structure.

Violating CQS. Looking For Suggestions And Alternatives.

derick.bailey — Fri, 05 Jun 2009 18:50:32 GMT

When doing simple input validation on forms, I often end up writing a lot of code like this:

     public void SaveRequested()

    {

     bool descriptionIsValid = ValidateDescription();

     bool abbreviationIsValid = ValidateAbbreviation();

     bool isValid = (descriptionIsValid && abbreviationIsValid);

     if (isValid)

     {

       VisitType visitType = new VisitType(Description, Abbreviation);

       VisitTypeRepository.Save(visitType);

     }

    }

    private bool ValidateAbbreviation()

    {

     bool isValid = !string.IsNullOrEmpty(Abbreviation);

     if (isValid)

       View.HideAbbreviationRequiredMessage();

     else

       View.ShowAbbreviationRequiredMessage();

     return isValid;

    }

    private bool ValidateDescription()

    {

     bool isValid = !string.IsNullOrEmpty(Description);

     if (isValid)

       View.HideDescriptionRequiredMessage();

     else

       View.ShowDescriptionRequiredMessage();

     return isValid;

    }

I recognize the violations of Command-Query-Separation in this code, and potentially other issues in design and implementation. The ValidateDescription and ValidateAbbreviation methods are fairly horrendous, from a CQS perspective. They are both querying the data to see if it’s valid, and also executing commands if it is or is not valid. Then on top of that, the SaveRequested method is executing another set of commands if both Description and Abbreviation are valid.

The requirements of this functionality are:

If Description is null or empty, show the “Description Required” message
If Abbreviation is null or empty, show the “Abbreviation Required” message
If both Description and Abbreviation are ok, allow the save to happen.

I’m not considering the difference between active and passive validation (on typing, vs on clicking save) in this example. That’s a different discussion for a different time.

So, how do you handle this type of input validation, accounting for CQS, code readability, testability, etc? I’m looking for suggestions and alternatives to this type of ugly code. I have a lot of my own ideas, but before I travel too far down the road, I want input from the rest of the world.

Note On Responses: As a suggestion for responding – if your response will take more than a few lines of very simple code and text, I’d really like to see your full response on your blog. Post a comment here (or pingback/trackback from your post) when you have your post up. If you don’t have a blog to respond with – shame on you! Blogspot.com is free. Go get a blog and respond. :)

I’m Presenting SOLID At AlamoCoders On June 9th

derick.bailey — Wed, 03 Jun 2009 21:25:37 GMT

~~I may be jumping the gun a bit, since it’s not posted on the~~ ~~AlamoCoders~~ ~~site, yet. :)~~

The AlamoCoders site has been updated to show my presentation. Please note that there is a different start time than usual - 5:30pm – to facilitate the 1.5 hours+ that my presentation takes.

On Tuesday, June 9th, I’ll be giving my SOLID Presentation at AlamoCoders, down in San Antonio. I’m looking forward to the opportunity, and am hoping to see Joe, Jason, Ryan, etc in their native town! This is the same SOLID presentation that I did at Austin Code Camp last weekend. I’d like to give a huge thanks to all the AlamoCoders that I got to hang out with at ACC, for giving me this opportunity, too.

The Presentation Abstract

Austin Code Camp 2009 Was A Ton-O-Fun!

derick.bailey — Mon, 01 Jun 2009 16:33:54 GMT

First and foremost - thanks to John Teague and Eric Hexter for organizing such a great event. It was as good, if not better than any of the previous Code Camps. The content was tremendous, the speakers were great, the attendees were passionate and eager to ask questions! Everyone that was there really pulled together a great conference.

My Presentations

My SOLID presentation was probably my best presentation to-date. It was fun, I felt good, and I am honestly overwhelmed by how much positive feedback I received from this presentation. People from all over Texas, and as far away as Arkansas are asking me to do this presentation at their local user groups! I really do feel blessed to been able to deliver this presentation to such a packed room of people – and I’ve seen a few tweets about people that couldn’t even get into the room!

My Decoupling Workflow Presentation went about as well as I expected. It was a little disjoined, I presented some things in the wrong order, and had a hard time keeping the audience interested at times. For those of you who provided feedback on this, THANK YOU! I have some great ideas on how to improve this by restructuring and reorganizing. I sincerely hope that you took at least something away from that session.

Presentation Material

For those of you who are interested in obtaining the presentation materials, you can get them from the Austin Code Camp Subversion repository @ Google code.

Pictures and Video

A recording of my SOLID presentation was made – and I can’t remember the name of the guy who did it! D’OH! I was promised that it would be posted online somewhere – maybe Youtube or something – so that we can share it with the world. If anyone has any pictures or video of this presentation, please contact me (myfirstname@firstnamelastname.com) with info on where it’s posted, or how I can get a copy of it so that I can post it.

A coworker (Michael Adkins) made a few short video clips of my SOLID presentation.

Here are some pictures that I took, and some that my coworkers took with my camera, at #ACC09.

Announcing Pablo’s E-Books! Book #1: Pablo’s SOLID Software Development

derick.bailey — Wed, 20 May 2009 01:37:03 GMT

Hello World! I’m happy to announce the first Los Techies compiled, Pablo endorsed, E-Book:

Pablo’s SOLID Software Development

“S.O.L.I.D. is a collection of best-practice object-oriented design principles that you can apply to your design to accomplish various desirable goals like loose-coupling, higher maintainability, intuitive location of interesting code, etc.”

This tremendous volume of information is a conglomeration of blog posts and other information produced by the LosTechies crew, and includes over 80 pages of information on how to work with the principles in question. From page 1 of the E-Book:

So what are you waiting for? Go download the greatest compilation of SOLID information ever produced by Los Techies bloggers!

Credits Due

I’d like to give a huge thanks to our fellow Pablo-ite, Sean Biefeld, for the hard work he put into the editing of this document. He spent a good deal of time ensuring the formatting of content was good to go. Jason Meridth and Joe Ocampo also need some props for getting the e-book posted so quickly. And give a shout-out to a Los Techies blogger the next time you see one for providing such a great compendium of SOLID information via the March 2008 Pablo’s Topic Of The Month, as well as the other SOLID contributions that made it into the site at later times.

Result: Directing Workflow With A Return Status And Value

derick.bailey — Tue, 19 May 2009 14:35:34 GMT

I often code user interfaces that have some sort of cancel button on them. For example, in my upcoming ‘Decoupling Workflow’ presentation, I have the following screen:

Notice the nice cancel button on the form. The trick to this situation is that I need to have my workflow code understand whether or not I clicked Next or clicked Cancel. Depending on the button that was clicked, I need to do something different in the workflow. If I click cancel, throw away all of the data that was entered on the form. If I click next, though, I need to store all of the data and continue on to the next screen.

The Result<T> and ServiceResult

In the past, I’ve handled these types of buttons in many, many different ways. I’ve returned null from the form, I’ve checked the DialogResult of the form, I’ve done out parameters for methods, and I’ve done specific properties on the form or the form’s presenter to tell me the status vs the data. Recently, though, I’ve begun to settle into a nice little Result<T> class that does two things for me:

Provides a result status – for example, a ServiceResult enum with Ok and Cancel as the two options
Provides a data object (the <T> generic in Result<T>) for the values I need, if I need them

Here is the code for my ServiceResult and my Result<T> object.

     public enum ServiceResult

    {

     Ok = 0,

     Cancel = 1

    }

    public class Result<T>

    {

     public ServiceResult ServiceResult { get; private set; }

     public T Data { get; private set; }

     public Result(ServiceResult serviceResult): this(serviceResult, default(T)){}

     public Result(ServiceResult serviceResult, T data)

     {

       ServiceResult = serviceResult;

       Data = data;

     }

    }

Putting Result<T> To Work

With this simple little solution, I can create very concise and clear workflow objects that know how to handle the cancel button versus the next button. The code becomes easier to read and understand, and makes the real workflow that much easier to see. The workflow code that runs the “Add New Employee” process for the screen shot above, is this:

    public void Run()

    {

     Result<EmployeeInfo> result = GetNewEmployeeInfo.Get();

     if (result.ServiceResult == ServiceResult.Ok)

     {

       EmployeeInfo info = result.Data;

       Employee employee = new Employee(info.FirstName, info.LastName, info.Email);

       Employee manager = GetEmployeeManager.GetManagerFor(employee);

       manager.Employees.Add(employee);

     }

    }

Notice the use of Result<EmployeeInfo> in this code. I’m checking to see if the result.ServiceResult is Ok before moving on to the use of the data. The GetNewEmployeeInfo class return a Result<EmployeeInfo> object from the .Get() method. The EmployeeInfo object contains the first name, last name, and email address of the employee as simple string values (and in the “real world”, the EmployeeInfo object would probably contain the input validation for these).

Because Result<T> is a generics class and returns <T> from the .Data property, I can specify any data value that I need and it returned from the presenter in question. This is where the real flexibility of the Result<T> object comes into play. When I have verified that the user clicked OK, via the result.ServiceResult property, I can then grab the real EmployeeInfo object out of the result.Data parameter which isstrongly typed to my EmployeeInfo class. Once I have this data in hand, I can do what I need with it and move on to the next step if there are any.

Conclusion

Having tried many different approaches to workflow code, I’m fairly well settled into this pattern right now. That doesn’t mean it won’t evolve, though. The basic implementation would cover most of what I need right now, but could easily be extended to include different “status” values instead of just the ServiceResults of OK and Cancel. Overall, though, this simple Result<T> class is saving me a lot of headache and heartache trying to figure out what to return from a method so that a workflow can figure out if the user is continuing, cancelling, or whatever.

A .NET (C#) Developer’s .gitignore File

derick.bailey — Tue, 19 May 2009 02:55:26 GMT

As a recent convert to the awesomeness that is git (my current flavor is msysgit), I find myself continuously needing to update the .gitignore file that I copy and paste between my repositories. Here’s what my ignore file currently contains:

     obj

    bin

    deploy

    deploy/*

    _ReSharper.*

    *.csproj.user

    *.resharper.user

    *.resharper

    *.suo

    *.cache

    ~$*

The “~$*” line is for MS Office temp files. Other than that, it’s a pretty common list of files and folders that .NET (C#) developers would want to ignore in the git repositories.

What does your .gitignore file look like? What am I missing from mine?

I’m Presenting At Austin Code Camp 2009

derick.bailey — Tue, 19 May 2009 01:29:32 GMT

As Chad so eloquently stated, this year’s AustinCodeCamp really is going to be better than bacon! And I feel honored to be one of the better than bacon speakers at this year’s event.

I’m delivering two presentations:

The SOLID presentation that I gave at the Austin .NET User Group last October
And a new presentation on Decoupling Workflow From Forms.

SOLID Software Development: Achieving Object Oriented Principles, One Step At A Time

Almost every professional software developer understands the academic definitions of Coupling, Cohesion, and Encapsulation. However, many of us do not understand how to actually achieve Low Coupling, High Cohesion, and strong Encapsulation, as prescribed. Fortunately, there are a set of stepping stones that we can use to reach these end goals, giving us a clear cut path to software that is easier to read, easier to understand, and easier to change. This presentation will define not only the three object oriented goals, but also the five S.O.L.I.D. principle that lead us there, while walking through a sample application.

You can download the slides and code for this presentation from here at LosTechies, or from the Austin Code Camp subversion repository closer to / during / after the event.

Decoupling Workflow From Forms With An Application Controller And IoC Container

In the development and maintenance of a WinForms application, using a Model-View-Presenter setup, over the last two years, I've ran into a fairly significant challenge: I had my workflow between forms coupled to the forms directly. For example, to get from MainForm to SubForm, code inside of MainForm would instantiate SubForm, it's Presenter, and all of the dependencies of each of thesse. In this application, the form codebehind would often contain several hundred lines of code to create all the needed views, presenters, etc for a workflow - per workflow. By introducing the concept Application Controller, in combination with a good IoC Container, we can quickly and easily reduce the tight coupling between our forms, while simplifying our presenters and enabling the workflow to change independently of the forms and presenters.

I’m (embarrassingly) still writing the presentation and code for this session. However, you can get a few sneak peaks of the presentation in these two blog posts:

You can also keep up to date with the presentation as I’m creating it, over at my Github account.

The Code Camp

Come join the fun on May 30th, down in Austin! The event is being held at the same place that it’s been for the last 4 years. Head over to the official website for more information. Also check out Chad’s post, linked above, for some great links to other information about ACC.

Last, but definitely most important: We all need to give a huge round of thanks to John Teague and Eric Hexter for putting together this event. They’ve done a tremendous job of organizing the sponsors, the facilities, and getting the schedule of speakers lined up.

Balsamiq And A Sneak Preview Of My ‘Decoupling Workflow’ Presentation

derick.bailey — Fri, 15 May 2009 01:25:23 GMT

I know I’m late jumping on this bandwagon, but it’s better late than never, right? :)

I decided to try out the Balsamiq Mockups tool while working on my sample application for the ‘Decoupling Workflow from Forms’ presentation that I’m planning (hoping! Go vote for my session!) to give at this year’s Austin Code Camp. The code for the presentation will revolve around a very simple “Org Chart” set of features, illustrating the principles and patterns of Application Controller, IoC containers, and others.

The Org Chart Screens

I’ve played with Balsamiq in the past, but never for an actual project. In less than 30 minutes, I was able to come up with the following screen layouts for my presentation.

The “Org Chart” Main Form

The “Add New Employee – Info” Form

The “Add New Employee – Manager” Form

The general workflow between these screens should be fairly intuitive. You can select an employee from the treeview, in the main form, and see their details. You can also click the “Add New Employee” button to go through the wizard-style process of adding a new employee’s information and selecting their manager.

It’s a very simple system, but it contains just enough elements to illustrate all of the concepts in my presentation. I’ll be using an Event Aggregator to know what user information to display, after selecting someone in the treeview. I’ll use a command object to start up the Add New Employee wizard, facilitated with a workflow service. And, it will all be wired together at runtime, with the StructureMap IoC container, illustrating the very low coupling that I am going for.

Balsamiq – It’s Not Just A Great Condiment With Chicken!

Overall, I’m very happy with the ease and usability of Balsamiq. The UI toolset that Balsamiq comes with is quite large, and is composed of the most often used, most fundamental UI elements. And with the data editing capabilities (titles, captions, lists, etc) that are available on each of the controls, it takes almost no time to string together to create compelling design. Even for the UI that aren’t covered by the default tools, there are user contributed controls that you can download and add from MockupsToGo.net!

One Minor Critique

Honestly, the only glaring issue that I have with Balsamiq is the name itself. Technically, the product name is “Balsamiq Mockups”. My problem with this name comes from being heavily influenced by the user experience realm of software development. The products of Balsamiq are not “mockups”, they are wireframes. Mockups are usually full color, highly detailed, almost-production-ready renderings.

Seriously… that’s the only problem I have with this product, at this point.

The Verdict

Balsamiq Mockups is a tremendous tool that all software developers and designers should have in their toolbox. It may not “wow” your socks off with all the “cool” of an iPod or iPhone, but it doesn’t need to. It’s simple. It sticks to what it does well. And it does what it does, exceptionally well. Most importantly, though - it doesn’t get in your way when you’re trying to let the creative design juices flow! The only thing that is less intrusive is a whiteboard and markers, but that solution doesn’t let you drag, drop and resize without erasing and starting over. :)

Go spend 10 minutes trying out the online version and then spend the $79 to buy the desktop version.

Balsamiq Mockups
Try It Now – the online demo (with some limitations)
Buy The Desktop Version

There are also versions that integrate with Atlassian’s Confluence and Jira, and the XWiki system, making it that much more attractive.

The Disclaimer / Full Disclosure

To keep myself and my blog honest, I do want to note that I was given a free $79 license for the desktop edition of Balsamiq Mockups. This review is essentially my “payment” for the free license. I do want to note, however, that I am not endorsing this product simply for the sake of a license. If I felt the product was not worth my time, I would say so. The truth is, I have been prompting the user experience team at my office to look into Balsamiq and do demos to the rest of the development department. I’ve recommended it to friends and other bloggers. And most importantly – I would have paid the $79 for the license if my request for a “blogger” license was denied. It really is worth the money.

FluentNHibernate Contrib (FNH.Contrib) Is Alive!

derick.bailey — Thu, 14 May 2009 02:14:06 GMT

A few months ago, a coworker created a set of extension methods to turn NHibernate’s Criteria API into a more fluenty, strongly typed API. We’ve been using it in a production app for a few months, and I wanted to share it with the world. After talking about it with the other Fluent NHibernate contributors, we decided that it was not a good time to introduce new APIs and features into FNH right now (especially considering that we just removed Repository and Linq from FNH).

Thus, FNH.Contrib was born!

FluentNHibernate.Query

Right now the only project in FNH.Contrib is the fluent query API. The basic idea was to turn a standard NHibernate Criteria query, like this:

     IList<Fault> faults = Criteria

                 .Add(Expression.Eq("FaultNumber", faultNumber))

                 .Add(Expression.Eq("AdminNumber", adminNumber))

                 .CreateCriteria("UIC")

                 .Add(Expression.Eq("UIC", uic.UIC))

                 .SetMaxResults(1)

                 .List<Fault>();

     if (faults != null && faults.Count > 0)

       fault = faults[0];

Into a more strongly typed, no-magic-strings API, like this:

    fault = Session.GetOne<Fault>()

                 .Where(f => f.FaultNumber).IsEqualTo(faultNumber)

                 .And(f => f.AdminNumber).IsEqualTo(adminNumber)

                 .AndHasChild(f => f.UIC)

                        .Where(u => u.UIC).IsEqualTo(uic.UIC)

                        .EndChild()

                 .Execute();

The syntax is not perfect, by any means. However, it’s a great start and it’s been in a production app for several months now! I’m hoping to continue expanding this, cleaning up the syntax, etc, as I start using it in more projects.

Moving Forward and Other Contributions

At the moment, there are no other contributions in FNH.Contrib. However, I would love to get input and other projects up and running in it. There was some brief discussion of moving the FNH Repository and Linq APIs into. Perhaps that’s a good place to start?

I also plan to put in a complete Rake based automated build, and hopefully get a full suite of unit tests wrapped around the code, moving forward.

How To Contribute

FNH.Contrib is being hosted over at Github:

http://github.com/derickbailey/FNH.Contrib/tree/master

If you would like to contribute, just fork the master repository and start plugging your contributions in! When you have something ready to go, send me a pull request and we can start putting together a more complete contrib library.