Los Techies

Ping-pong Pairing Session Screencast with Ben Scheirman

chadmyers — Wed, 14 May 2008 05:12:08 GMT

Well, it's two-fer Tuesday here at Los Techies, I guess! By pure coincidence, Ben Scheirman wrapped up the post-production of a screencast we did a few weeks ago.

Ben Scheirman just recently posted on his blog about it.

Ben did a LOT of work trying to get the video and audio in sync and did a heroic job. We still have a lot to learn about how to get everything to work together (audio, video, shared Internet connection), so please forgive us on the unprofessional nature of the screencast. We're developers messing around with screencasts, this isn't our day job! :)

The Screencast can be viewed here:

http://www.benscheirman.com/screencasts/tdd-inventory

Just like Ben did in his post, I'd like to establish a few caveats:

I'm not a TDD expert! I make no claims of canon here or that this is official TDD or BDD gospel. Please take with a grain of salt!
Our main goal was to have a pairing session using TDD and record it. We started out trying to teach some TDD fundamentals, but it just turned into a cool jam session
We had a lot of technological problems w/r/t Skype dropping calls.
We had some time sync issues with the audio, so the audio and the video get out of sync part way through the video, but it's still worth watching part of it
Sorry for the length, hopefully you can zip around and find stuff that's interesting and then back up a little to see what you want to see.

Anyhow, there's lots of good stuff in there, and I hope someone gets some useful into out of it.

I can't speak for Ben, but I know I'd definitely like to keep trying this sort of thing in the future -- hoping that the technological issues would work themselves out and Ben wouldn't have to kill himself just to get the audio lined up!

ALT.NET Podcast on Continuous Improvement

chadmyers — Wed, 14 May 2008 01:16:55 GMT

Mike Moore recently put together a podcast about ALT.NET and Continuous Improvement featuring Jeremy Miller, David Laribee, and, in order to make the other guys sound smarter, me.

Please check it out and let us all know what you think!

From what I understand, the 'Alt.NET Podcast' folks are planning on doing many more episodes, so you may want to subscribe to their feed and stay on top of it in the future.

OT: You Can Save Lives

chadmyers — Sat, 10 May 2008 14:59:43 GMT

I debated about posting this on a technical blog and abusing the relationship with my subscribers, but I believe that the benefits outweigh the negatives. Lives are stake, people are suffering, and many of YOU can help. I hope you agree that this post is worth it.

I know many of you have families and several of you are expecting a new addition. I would like to humbly ask you to consider donating the umbilical cord blood to your local Cord Blood Bank. In Texas, the Texas Cord Blood Blank is in San Antonio. Most states have a Cord Blood Bank (usually in conjunction with a hospital or a regular blood bank). Please see if there's one in your state.

Many people are capturing the cord blood after birth and storing it for treatment of their own family should any of the problems arise that cord blood can treat. This is great and you should seriously consider doing this. I would also like to suggest you consider donating some or all of it to your local/regional blood bank for those who are more likely (or who already have) these life-threatening conditions. People with horrible diseases like Leukemia, lymphoma, sickle cell anemia, and cancer are being treated TODAY and some have had remarkable recoveries due to Cord Blood therapy.

Why am I doing this on my blog? Because so far most hospitals and midwives don't know that you can save the Cord Blood and bank it and so they don't think to ask women before or during labor whether they want the blood to be saved. At this time, you must ASK for it. If your family is expecting, I strongly encourage you to look into this and decide if the risks are low enough and benefits high enough to help give someone life-saving therapy.

From what I understand, several major insurance carriers are starting to cover the collection procedure as well as the on the recipient side, the transplant procedure because it is a demonstrable and scientifically proven medical success.

Benefits of cord blood:

There is very little risk to the donor.
Since cord blood immune cells are less mature, they are more easily accepted by the patient when used in transplantation. As a result, patients with a less than perfect immune match can now be treated
There are fewer immune complications after transplantation.
Since cord blood is banked and ready to use, it is immediately available when a patient needs it.

Some of the diseases currently treated with cord blood:

Leukemia & other blood cancers
Aplastic anemia
Lymphoma
Deficiencies of the immune system
Genetic disorders such as sickle cell anemia

LINQ query operators: lose that foreach already!

bogardj — Fri, 09 May 2008 23:11:31 GMT

Now that .NET 3.5 is out with all its LINQ query operator goodness, I feel like going on a mean streak of trashing a lot of our (now) pointless foreach loops. Some example operations include:

Transformations
Aggregations
Concatenations
Filtering

As I mentioned in my last post, temporary list creation is a great pointer to find opportunities for losing the foreach statements. I keep the foreach statement when the readability and understandability of the code drops with the LINQ change, but otherwise, a lot less temporary objects are floating around. Personally, the jury is still out for me whether it's clearer to return "IEnumerable<LineItem>" over "LineItem[]", but the temporary array creation doesn't seem to have much of a point.

Transformations

Transformations are easy to spot. You'll create a new List<Something>, then loop through some other List<OtherThing> and create a Something from the OtherThing:

public OrderSummary[] FindOrdersFor(int customerId)
{
    IEnumerable<Order> orders = GetOrdersForCustomer(customerId);
    List<OrderSummary> orderSummaries = new List<OrderSummary>();

    foreach (Order order in orders)
    {
        orderSummaries.Add(new OrderSummary
                            {
                                CustomerName = order.Customer.Name,
                                DateSubmitted = order.DateSubmitted,
                                OrderTotal = order.GetTotal()
                            });
    }

    return orderSummaries.ToArray();
}

Note the temporary list creation, just to return an array. With LINQ query operators, I can use the Select method to do the same transformation in less code:

public OrderSummary[] FindOrdersFor(int customerId)
{
    return GetOrdersForCustomer(customerId)
        .Select(order => new OrderSummary
                             {
                                 CustomerName = order.Customer.Name,
                                 DateSubmitted = order.DateSubmitted,
                                 OrderTotal = order.GetTotal()
                             })
        .ToArray();
}

By chaining the methods together, it comes out much more readable.

Aggregations

Aggregations can be found when you're looping through some list for some kind of calculation. For example, the GetTotal method on Order loops to build up the total based on each item's ItemPrice:

public decimal GetTotal()
{
    decimal total = 0.0m;

    foreach (LineItem lineItem in GetLineItems())
    {
        total += lineItem.ItemPrice;
    }

    return total;
}

Again, this can be greatly reduced using LINQ query operators and the Sum method:

public decimal GetTotal()
{
    return GetLineItems()
        .Sum(item => item.ItemPrice);
}

Not only is the code much smaller, but the intent is much easier to discern. Sometimes a calculation can be tricky, and in those cases LINQ isn't bringing anything to the table. As always, use good judgement and keep an eye on readability.

Concatenations

Oftentimes I need to combine many lists into one flattened list. For example, suppose I need a list of OrderLineItem summary items, perhaps to display on a grid to the end user. However, I want to display all order line items for all orders, which is difficult to build up manually:

public LineItemSummary[] FindLineItemsFor(int customerId)
{
    IEnumerable<Order> orders = GetOrdersForCustomer(customerId);
    List<LineItemSummary> lineItemSummaries = new List<LineItemSummary>();

    foreach (Order order in orders)
    {
        IEnumerable<LineItemSummary> tempSummaries = TransformLineItems(order, order.GetLineItems());

        lineItemSummaries.AddRange(tempSummaries);
    }

    return lineItemSummaries.ToArray();
}

Note the two temporary lists: one to hold the concatenated list, and the other to hold each result as we loop through. With the SelectMany method, this becomes much shorter:

public LineItemSummary[] FindLineItemsFor(int customerId)
{
    return GetOrdersForCustomer(customerId)
        .SelectMany(order => TransformLineItems(order, order.GetLineItems()))
        .ToArray();
}

No temporary lists are created, and all of the LineItemSummary objects are concatenated correctly. Nested foreach loops as well as the AddRange method are indicators that the SelectMany method could be used.

Filtering

Filtering looks similar to transformations, except there's an "if" statement that controls adding to the temporary list. Suppose we want only the expensive LineItemSummary items:

public LineItemSummary[] FindExpensiveLineItemsFor(int customerId)
{
    IEnumerable<Order> orders = GetOrdersForCustomer(customerId);
    List<LineItemSummary> lineItemSummaries = new List<LineItemSummary>();

    foreach (Order order in orders)
    {
        foreach (LineItem item in order.GetLineItems())
        {
            if (item.ItemPrice > 100.0m)
                lineItemSummaries.Add(new LineItemSummary
                                          {
                                              CustomerName = order.Customer.Name,
                                              DateSubmitted = order.DateSubmitted,
                                              ItemPrice = item.ItemPrice,
                                              ItemName = item.ProductName
                                          });
        }
    }

    return lineItemSummaries.ToArray();
}

This example has both concatenation and filtering. The filtering can be taken care of with the Where method, and we'll use the same technique earlier with the SelectMany method:

public LineItemSummary[] FindExpensiveLineItemsFor(int customerId)
{
    return GetOrdersForCustomer(customerId)
        .SelectMany(order => TransformLineItems(order, order.GetLineItems()))
        .Where(item => item.ItemPrice > 100.0m)
        .ToArray();
}

By adding the Where method, we can filter out only the expensive line items. The method chaining looks much better than the nested foreach loops coupled with the if statement, and got rid of the temporary list creation.

Lose the foreach

With the new LINQ query operators, any temporary list creation and foreach loop should be considered suspect. By understanding the operations LINQ gives us, we can not only reduce the amount of code we create, but the end result matches the original intent far better.

Not every foreach or temporary list should be removed, as sometimes long chains and large lambdas tend to muddy rather than clear the picture. But for a great deal of scenarios, LINQ query operators can vastly improve the readability of transformation (Select), aggregation (Sum), concatenation (SelectMany) and filtering (Where) sections of your code.

Don't Do That

hoffe — Fri, 09 May 2008 04:18:30 GMT

Over lunch today, I learned about one of the company's recent acquisitions. Here's the short of it:

The production system has between 6k-7k different Access databases (databases, not tables)
Since the app creates new databases on the fly, no one is sure which are production dbs

Don't ever do that. Please. And no, I couldn't make this one up even if I tried. ;-)

NAnt script for determining whether an assembly is registered in the GAC

chadmyers — Thu, 08 May 2008 19:53:29 GMT

A friend of mine, Kevin Miller, recently put out a public call for anyone who had some NAnt magic for detecting whether a given assembly is in the GAC or not. I had written something like this a year or so ago and I thought I'd share it with everyone in the hopes it might help you.

Standard disclaimer: I don't guarantee that this works, I don't guarantee that this won't explode your computer if you run it. I make no warrantees of any kind.

First, you have to have the .NET SDK installed. If you have Visual Studio 2005 or later, you do. If you're on a server, make sure you install the .NET Framework 2.0 SDK (free download from MS -- SDK x86, SDK x64, and SDK IA64) first.

At the top of your build script somewhere:

<property name="gacutil.exe" value="${framework::get-sdk-directory('net-2.0')}\gacutil.exe" />

Next, add the GAC check in a task somewhere (NOTE: Replace the YOUR_ASSEMBLY... with the name of the assembly to find without the ".dll" portion on the end):

<exec program="cmd.exe" failonerror="false" resultproperty="foundInGac" verbose="true"
    commandline="/c gacutil.exe /l YOUR_ASSEMBLY_NAME_WITHOUT_THE_DOT_DLL | %windir%\system32\find &quot;Number of items = 1&quot;">
    
    <environment>
        <variable name="PATH">
            <path>
                <pathelement path="%PATH%"/>
                <pathelement dir="${framework::get-sdk-directory('net-2.0')}"/>
            </path>
        </variable>
    </environment>
</exec>

In my particular case, I added a <fail> task to fail the build if that assembly was in the GAC because it could hose the versioning of my build. Here's how I did that:

<fail if="${int::parse(foundInGac) == 0}" message="The Core assembly is registered in the GAC. Please un-GAC this assembly before attempting to build the project."/>

I hope this helps someone.

Enhancing mappers with LINQ

bogardj — Thu, 08 May 2008 12:49:53 GMT

The "big 3" higher-order functions in functional programming are Filter, Map and Reduce. When looking at the new C# 3.0 LINQ query operators, we find that all three have equivalents:

Filter = Where
Map = Select
Reduce = Aggregate

Whenever you find yourself needing one of these three higher-order functions, just translate them into the correct query operator. "Select" doesn't have the same dictionary meaning as "Map", but the signature is exactly the same.

The trick to knowing you can use these higher order functions is to look out for situations where you:

Create a new collection
Iterate through some other collection
Add items from the other collection to the new collection

Any time you see this general algorithm, there's a much terser syntax available with LINQ.

Mapper patter example

For example, consider the Mapper pattern:

public interface IMapper<TInput, TOutput>
{
    TOutput Map(TInput input);
}

A common scenario to map is when I'm creating DTOs or message objects from Domain objects. Serializing domain objects generally isn't a concern of the domain object, as DTOs tend to be flattened out somewhat. I might have the following domain objects:

public class Customer
{
    public Guid Id  { get; set; }
    public string Name { get; set; }
}
public class SalesOrder
{
    public Customer Customer { get; set; }
    public decimal Total { get; set; }
}

I'd like to send a Sales Order over the wire for display in some client application. But suppose the Customer object contains dozens of properties, perhaps things like a billing address, a shipping address, and so on. The service I'm creating only needs a summary of customer information, so I create a SalesOrderSummary message class:

public class SalesOrderSummary
{
    public string CustomerName { get; private set; }
    public Guid CustomerId { get; private set; }
    public decimal Total { get; private set; }

    // For serialization
    private SalesOrderSummary() { }

    public SalesOrderSummary(string customerName, Guid customerId, decimal total)
    {
        CustomerName = customerName;
        CustomerId = customerId;
        Total = total;
    }
}

The corresponding mapper would look like:

public class SalesOrderSummaryMapper : IMapper<SalesOrder, SalesOrderSummary>
{
    public SalesOrderSummary Map(SalesOrder input)
    {
        return new SalesOrderSummary(input.Customer.Name, input.Customer.Id, input.Total);
    }
}

Nothing too exciting so far, right? Well, suppose now I need to return an array of SalesOrderSummary, perhaps for display in a grid. In that case, I'll need to build up a list of SalesOrderSummary objects based on a list of SalesOrder objects:

public SalesOrderSummary[] FindSalesOrdersByMonth(DateTime date)
{
    // get the sales orders from the repository first
    IEnumerable<SalesOrder> salesOrders = GetSalesOrders();

    var salesOrderSummaries = new List<SalesOrderSummary>();
    var mapper = new SalesOrderSummaryMapper();

    foreach (var salesOrder in salesOrders)
    {
        salesOrderSummaries.Add(mapper.Map(salesOrder));
    }

    return salesOrderSummaries.ToArray();
}

This isn't too bad, but the creation of a second list just to build up an array seems rather pointless. But by borrowing some ideas from JP, we can make this a lot easier.

Using LINQ

We can already see the higher order function we need, it's in the name of the mapper! Instead of "Map", we'll use "Select" to do the transforming. But since we have the interface, we can create an extension method to do the Map function:

public static class MapperExtensions
{
    public static IEnumerable<TOutput> MapAll<TInput, TOutput>(this IMapper<TInput, TOutput> mapper, 
        IEnumerable<TInput> input)
    {
        return input.Select(x => mapper.Map(x));
    }
}

This new MapAll function is the functional programming Map function, where it takes an input list and returns a new IEnumerable with the mapped values. Internally, the Select LINQ query operator will loop through our input, calling the lambda function we passed in (mapper.Map). This is the exact same operation in our original example, but now our service method now becomes much smaller:

public SalesOrderSummary[] FindSalesOrdersByMonth(DateTime date)
{
    // get the sales orders from the repository first
    IEnumerable<SalesOrder> salesOrders = GetSalesOrders();
    var mapper = new SalesOrderSummaryMapper();

    return mapper.MapAll(salesOrders).ToArray();
}

Much nicer, our service method is reduced to just a handful of lines. The nice thing about this syntax is that it removes all of the unnecessary cruft of a temporary list creation that clouded the intent of this method.

So any time you find yourself creating a temporary list just to build up some filtered, mapped or reduced values, stop yourself. There's a higher calling available with functional programming and LINQ.

Mike Cohn in town

bogardj — Wed, 07 May 2008 12:26:20 GMT

Mike Cohn, author of User Stories Applied and Agile Estimation and Planning, is speaking tomorrow night as a part of Agile Austin's Distinguished Speaker Series. The topic is "Succeeding with Agile: A Guide to Transitioning", with the description:

Transitioning to an agile development process is unlike most transitions an organization may make. Many transitions begin when a strong, visionary leader plants a stake in the ground and says, “Let’s take our organization there.” Other transitions start with a lone team thinking, “Who cares what management thinks, let’s do this.” The problem in transitioning to agile is that neither of these approaches alone is likely to lead to the long-term sustainable change required.

In this session we will look at the primary reasons why agile transitions fail and how to overcome them. We will explore what is necessary for self-organizing teams to emerge and thrive within the transitioning organization. We will also the role self-organization must play during the transition itself. This session will include a description of the eight primary ways of getting started—including going All In, Start Small, and Impending Doom—and the advantages of each. You will leave knowing what approach will work best for you as well as what you must and must not do to succeed with agile.

Transitioning to Agile is a very bumpy ride, as the rise in communication works to surface problems that were previously hidden and swept under the rug. Mike's books have had a large influence on how I approach software, so I'm pretty excited about Mike coming to town. The registration fee for non-Agile Austin members is $10, or in my terms, 20 tacos from Jack in the Box.

For more information, check out the event page:

http://mikecohnpresentation.eventbrite.com/

I know it's not Hannah Montana, but it should be a nice event nonetheless.

VMware Fusion 2.0 Beta 1

Chris Patterson — Tue, 06 May 2008 13:59:10 GMT

It looks like VMware has dropped a public beta of VMware Fusion 2.0 to the public. There are too many new features in this release to mention, so I will just share the link:

http://communities.vmware.com/community/beta/fusion

Be sure to check the release notes to see if they impact your work before upgrading to this beta release.

Items of interest I took away from the release notes:

Use Fn+M to simulate the non-existent insert key in Windows (hello R#)
Multiple display support for virtual machines (hello second monitor)
Improved compatibility with Visual Studio (not sure what this is yet)

Be sure to check it out!

PabloTV: Eliminating static dependencies screencast

bogardj — Tue, 06 May 2008 12:24:13 GMT

Nature abhors a vacuum. It turns out she also abhors static dependencies (I have my sources). Static dependencies are the modern-day globals, often exposed through classes named "Helper". I've certainly been guilty of overusing static dependencies in the past, with classes like "LoggingHelper", "SessionHelper", "DBHelper" and so on.

The problem with static dependencies is that they are opaque to the extreme, enforcing a strong coupling that is impossible to see from users of the class. To demonstrate techniques for eliminating static dependencies, Ray Houston and I created a short screencast:

Eliminating static dependencies screencast

Our screencast demonstrates using TDD along with ideas and techniques laid out in Michael Feathers' Working Effectively with Legacy Code and Joshua Kerievsky's Refactoring to Patterns. It details how to make safe, responsible changes to an existing legacy codebase, while improving the design by breaking out dependencies to a static class.

Hope you enjoy it!

A pointless exercise

bogardj — Mon, 05 May 2008 12:40:40 GMT

I caught this last night from Scott Hanselman on Twitter:

http://www.betterwebapp.com/drupal/?q=screencasts

It's a side-by-side comparison of the time to create a simple web app for:

Ruby
Perl
ASP.NET
Java

The website compares a few other frameworks to compare which languages and frameworks are the fastest to develop against. Not that it matters, but ASP.NET came out on top for the simple application profile, while Python/Django came out on top for the three-tier application profile.

While viewing the screencast, all I could think was "Holy jeebus, is there a more pointless exercise than timing the creation of software?" Creating software is easy (some would say too easy). If our problem was "how fast can we whip out software", the issues of today's software developers would have been solved decades ago.

The problem is that software maintenance dwarfs the cost of software creation, by a factor of at least 3 to 1. So if we're trying to optimize software development, isn't it the most expensive aspect, maintenance, what we should focus on? We use ReSharper to optimize responsible code creation (i.e., micro-codegen vs. macro-codegen), but it also helps with responsible code maintenance through automated refactorings. Many other responsible engineering practices, such as those espoused by XP, aim to reduce the maintenance costs of software development.

In the end, I could care less how long it takes to slap out some sample application. In six years of professional development, no one has ever paid me to write an application on the level of what was demonstrated. Some managers will care how fast you sling code, but the smart ones care about:

Can the software you created be easily changed?
Can the software you created be easily tested?
Can the software you created be easily deployed?
Can the software you created be easily diagnosed for bugs?
Is the software you created correct?
Is the software you created what we actually need?

I'd love to see those issues in a screencast, but who would want to watch a screencast that lasted for weeks or months?

A Very Poor Object Model Is Really No Object Model At All

hoffe — Mon, 05 May 2008 02:59:02 GMT

First let me say that I've met Keith personally, and he's a really cool guy. Cool enough in fact, that he's on my RSS subscription list. I'd consider him a friend. :-)

This is my response to his recent post, How To Not Screw Up Your Application Object Model. I'll also point to Arnon's reaction.

Exhibit A:

This is a very, very poor object model. It's a very poor object model even if it perfectly represents the business requirements. I'm going to nickname this the "college freshman" object model, and we all know how useful college freshmen are in the real world (and just how much they have to learn before they become useful). In short, never do this--again, even if it perfectly represents your business problem (which it won't).

I'll also repeat what Arnon said. In a nutshell, don't use a bulldozer where a simple shovel will do. Building an app for a vet is a good candidate for CRUD and Microsoft Access. Don't overcomplicate your solution.

Also, if you are developing outside the guidance and expertise of the customer, you greatly increase your chances of failure and waste. Don't do that. It's irresponsible and foolish.

I'd also like to point out that this object model is driven by the C++ object model thinking of yesterday. We've learned a lot since the 70's and 80's, and that includes how to do objects.

I'll point out two very important facts that are rather obvious:

We don't have multiple inheritance in C# or VB.NET. That greatly affects how we do OOP.
Inheritance is a very fragile. 99% of the time it's the wrong tool to use (as this diagram elegantly illustrates)

Luckily, we've learned a lot in the past 10 years and evolved our design techniques since then.

Inheritance is the old stuff. Composition is the new stuff. We've learned about the fragile base class problem and moved on. A solution using composition (instead of inheritance) yields way more flexibility and is much more resilient to change (when used properly). Where inheritance represents the relationship with the most coupling between two classes, composition allows us to freely decouple two (or more) classes.

Is bad OOP really bad OOP or is it just not OOP at all?

If you've implemented a deep type hierarchy in your .NET app while trying to build an "object model", you've sorely misunderstood how to apply OOP in .NET.

In conclusion, I'd like to challenge Keith to write a new post on the following:

The reason is because we have been beat to death with OOP principles.

I'd be curious as to what principles you are referring to. I get the feeling that the OOP principles you are referring to are completely different from the ones I follow. I'd love to carry this discussion further.

Tying up loose ends

chadmyers — Mon, 05 May 2008 02:53:45 GMT

Blogging Stuff

Just in case anyone was following/caring, I had started a few multi-part series posts that kind of fizzled out and I felt I owed the 3 of you who cared an explanation:

Agile Arguments: No one seemed to pick up or care about this one. I have a two half-written parts to this, but I'm not going to flog myself to finish them if there's no interest.
Pablo's Topic of the Month for April: Design Patterns - no one else chimed in on this one. April was rough for a lot of people and we just didn't get it done. Sorry folks :( We're human. We may try something for May, or pick it up again in June with a new topic (hopefully something that requires a little less investment so we can get back up to speed)

I think I might back away from heady posts altogether and get back to more code/task-oriented posts. There's a ton of stuff out there and I'd like to start doing some real-world minutiae stuff with some test-driven design, IoC, or other stuff I preach sneakily thrown in there in the hopes that that might be a more effective strategy for getting people excited about some of these accelerators I have found.

Community Stuff

CodingDojo

The next incarnation of the TDD CodingDojo was planned for April, but my job situation + ALT.NET Seattle threw a wrench in that. May turned out to be for similar reasons. So the current plan is some time in June (hopefully early). We'll see. Several of you have offered to help set up something and we (and I think I can speak for the Los Techies crew here) really appreciate the offer and we'll probably be calling on you sometime soon.

Screencasts

I recorded a screencast with Ben Scheirman a few weekends ago and it worked out pretty well, I thought. Unfortunately there was some temporal distortion between our two audio streams, and last I checked he was slogging it out doing some grunt work to get it straightened out (thanks Ben!) If anyone knows why one audio stream slowly gets out of sync with the other (i.e. about 1 second every few minutes), we'd appreciate some help.

Ray Houston and Jimmy Bogard just recorded a screencast and it's coming together nicely in post-production. Look for one of them (hopefully) to post about this soon (great job guys!)

I'd encourage all four of you who read my blog to consider doing a screencast. It's a lot easier to do it in person, so if you're in Austin maybe we could set something up together?

DotNetSlackers and other sites

The crew over at DotNetSlackers.com are doing some pretty cool things and they're asking for folks to help write articles, send in snippets, etc. I going to *try* to do some of these in the near future (I keep promising Sonu, but never following up -- sorry man).

I'd like to suggest anyone who has even simple snippets or interesting ASP.NET MVC usage examples, or maybe even NHibernate 101 stuff, contributing it to DotNetSlackers to further the art. They're clamoring for high quality content and they're even willing to PAY for content! Yes, that's right, pay! :) It's in your professional as well as personal interests to contribute to a site like this (disclaimer: I have no affiliation with this site other than being an occasional forum poster and I received no money or other compensation to say any of this -- I just like the site).

A Reader Challenge

hoffe — Mon, 05 May 2008 01:46:08 GMT

This is a simple challenge. I want you to figure this out for yourself. It's an important step I think every developer needs to take for him/herself.

Also, please don't give any direct answers in the comments or I will delete them. Non-answer comments are perfectly acceptable. :-)

Without further ado, can you please give a simple definition and compare the following:

Procedural Code
Object-based Code
Object-oriented Code

In particular, what's the difference between object-based code and object-oriented code? I'll give you a clue, it doesn't particularly have anything to do with inheritance.

You might find these concepts in a few books. I'll drop a couple references here.

C++ Primer (Parts 3, 4, and 5)
Object-Oriented Design Heuristics

Finally, I'll leave you with a slightly harder teaser problem. What's an "Object Role"?

If you are unsure, feel free to drop me an email, and I'll steer you in the right direction (evanatevanhoffdotcom). I'm not recommending those books for starters (although I'm sure they are great books).

Connecting ActiveRecord to SQL Server

Ray Houston — Sat, 03 May 2008 16:13:36 GMT

Disclaimer: I'm a Ruby noobie. I know nada about Rails. Please leave a comment if something is not correct or if there is a better way to do this.

At work, we're using Watir to drive a Silverlight application for some automated end to end testing. We needed an easy way to access the database from our RSpec test fixtures to make sure the proper setup data is put where we need it. I discovered that ActiveRecord can be used without rails and that all I needed to do was just install the gem. Typing the following seemed to do the trick for me:

gem install activerecord

I then found this which told me that I have install the SQLServer adapter separately like so:

gem install activerecord-sqlserver-adapter --source=http://gems.rubyonrails.org

It then also says that one must get the latest source distribution of Ruby-DBI from here and copy the file:

lib/dbd/ADO.rb

to your Ruby installation directory in the following place:

X:/ruby/lib/ruby/site_ruby/1.8/DBD/ADO/ADO.rb

After that I was able to create a simple test page to see if could actually get connected.

ActiveRecordTest.rb

require 'active_record'

ActiveRecord::Base.pluralize_table_names = false

ActiveRecord::Base.establish_connection(
    :adapter => "sqlserver",
    :host => ".\\SQLEXPRESS",
    :database => "MyDB",
    :username => "sa",
    :password => "sa"
)

class Customer < ActiveRecord::Base
end

Customer.find(:all).each do |cust| puts cust.Name end

This test selects all the customers and outputs their names.

Technorati Tags: Ruby,ActiveRecord

Developers or engineers?

bogardj — Thu, 01 May 2008 00:50:12 GMT

I've had quite a few job titles where I basically did the same function: Software Engineer, Software Developer, Technical Lead, and so on. In some companies, a Software Developer is a completely different position than Software Engineer, and in others they're used interchangeably.

The connotations and implications from each title are strikingly different. The term "engineer" has a much different meaning than "developer", taken outside the context of software. A Developer might lay out the plan of a new subdivision, where its green areas are, what style homes should be built and what theme the neighborhood should adhere to. The Engineer lays out the water and sewage lines, elevations, roads, utilities and other functions vital for sustainable human habitability. A Developer creates the vision and designs the implementation, while the Engineer ensures that quality, regulatory and ethical standards have been met.

That's not to say an Engineer isn't creative. In a family full of Engineering graduates (including myself), no Engineer would have a job if they weren't creative. Every problem is an implementation of a different pattern, but the details make each challenge completely different than the one before.

Having worked with many types of real Engineers (i.e., they're doing the job they went to school for), I didn't see what they were doing was much different than me. They were concerned with:

Safety
Reliability
Maintainability
Aesthetics
Usability

As well as a host of other "ilities". One critical difference between me as a Developer and they as an Engineer was that Engineers are licensed by an independent group.

In many fields and jurisdiction, including Civil Engineering in Texas, licensing is required by law when performing engineering services for the public. Licensing isn't easy, either. To become a licensed Professional Engineer PE, you must:

Graduate from an accredited engineering program
Take an initial exam to become an Engineering-in-Training (EIT)
Have a minimum of 4 years experience as an EIT, preferably as an apprentice to another PE
Take a rigorous exam, which takes 6-8 hours to complete

Licensing isn't a one-time affair, you have to renew your license, which has its own requirements including continuing education. Even if not working in the public sector, licensing is considered a career necessity.

But we have certifications, right?

Anyone that has interviewed candidates for positions knows the sad state of software certifications. At best, software certifications signify that your are certified to be an absolute beginner for that topic. For some reason, software certifications still hold value, though all involved, managers, HR and candidates, know that the certifications aren't worth bytes it was emailed with.

Would licensing help our industry? We live in a sad state of affairs when identities are not stolen because of sifting through your mail or stealing your wallet, but because of careless, ignorant developers. In a Twitter conversation with an ex-colleague, Terry noted that software development lacked discipline, respect and accountability. Can licensing help prevent the ridiculous failures, by both raising the bar and raising the stakes for individual failure?

If a bridge fails, the engineers can be held liable if they are found to cut corners, or even sheer ignorance. Oversight in the form of inspectors is supposed to help, but in the end, the engineers are held accountable.

I see Developers as code monkeys, slapping code out without regard to reliability and maintainability. Engineers have a much longer horizon too look at, they must ensure the bridge they build lasts 100 years, not six months. Shouldn't we hold ourselves up to the same standard?

Open Spaces In Practice

Chris Patterson — Wed, 30 Apr 2008 04:04:59 GMT

After a great weekend in Seattle for the ALT.NET Open Spaces event (aside from a slight error in judgement on Friday night as depicted in this blog post), the two coworkers and I discussed how we could bring the experience of Open Spaces back to the team in Tulsa. We decided that instead of just giving a few talks about some of the things we took away from Seattle, we would bring the experience itself to the team.

At the end of our team meeting on Monday, we laid out some paper and pens and asked members of the team to write up topics that they wanted to discuss. It started a bit slow, but within minutes we had eighteen topics on the wall. The variety of topics was excellent, most of which targeted a different subset of the team. It was great to see the team come up with such a nice list of things for the team to discuss.

We then drew a grid of time slots on the whiteboard and asked the team to put their initials on the topics they wanted to attend. As the papers filled up, we started aligning them into the grid based on popularity and expected duration. We tried to keep all of them to an hour but some of the topics were given ninety minutes based on the content.

We had to negotiate on some of the topics to fit our time slots, and combined a couple of similar discussions into the same time period so that we could maximize our coverage over the next few days. Some topics were brought up that are timely to an upcoming release of our software, so those were given a slight priority in the schedule.

Overall, I was very impressed with the contributions by the team. Topics included things like "maximizing the use of Resharper", "What are unit tests", and "How can we test better?" With the large number of topics on the schedule, we're hoping that we can set aside a couple of days a week (maybe Tuesday and Thursday over lunch) to continue with more discussions. I'll be sure to post a follow up as things unfold over the next week.

xkcd2 - someone is wrong

Jason Meridth — Mon, 28 Apr 2008 17:40:00 GMT

Who was I thinking of when I read this? Oh, there are so many people. (mouse over for alt text, funny also -- you do this with all xkcd comics)

xkcd - ubuntu, python comics

Jason Meridth — Mon, 28 Apr 2008 17:34:00 GMT

If you don't currently read xkcd.com, you should be. It has some mushy lovey dovey junk in it sometimes, but the python references and open source references are hilarious.

Today's comic: (mouse over for the Ubuntu reference)

One of my other favs:

Nested classes with JUnit

jlockwood — Mon, 28 Apr 2008 14:56:00 GMT

Recently I was playing with JUnit 4.X. I wanted to be able to define tests in nested classes as I had before with NUnit. This was to facilitate BDD-ish test definitions, where I break up unit tests by test context. My first attempt failed (of course) because JUnit was unable to see the nested classes and the failed to run. After a bit of digging, I ran across a sparsely documented feature that allowed me to do what I wanted. Namely by using: @RunWith(Enclosed.class) Below is an example, hope it's...(read more)

Understanding Mock Objects: an alternate solution

bogardj — Mon, 28 Apr 2008 02:27:53 GMT

In AzamSharp's recent post Understanding Mock Objects, he poses a problem of testing with volatile data. His example extends on an article on AspAlliance, which exhibits the same problems with its solution. Suppose I have an image service that returns images based on the time of day:

public static class ImageOfTheDayService
{
    public static string GetImage(DateTime dt)
    {
        int hour = dt.Hour;

        if (hour > 6 && hour < 21) return "sun.jpg";

        return "moon.jpg";
    }
}

The initial test uses the current date and time to perform the test:

[Test]
public void should_return_sun_image_when_it_is_day_time()
{
    string imageName = ImageOfTheDayService.GetImage(DateTime.Now);
    Assert.AreEqual(imageName, "sun.jpg");
}

Since DateTime.Now is non-deterministic, this test will pass only some of the time, and will at other times. The problem is that this test has a dependency on the system clock. AzamSharp's solution to this problem was to create an interface to wrap DateTime:

public interface IDateTime
{
    int GetHour();
}

Now the ImageOfTheDayService uses IDateTime to determine the hour:

[Test]
public void MOCKING_should_return_night_image_when_it_is_night_time()
{
    var mock = new Mock<IDateTime>();
    mock.Expect(e => e.GetHour()).Returns(21); // 9:00 PM

    Assert.AreEqual("moon.jpg", ImageOfTheDayService.GetImage(mock.Object));
}

I really don't like this solution, as the test had the external non-deterministic dependency, not the image service.

Alternative solution

Here's another solution that doesn't use mocks, and keeps the original DateTime parameter:

[Test]
public void should_return_night_image_when_it_is_night_time()
{
    DateTime nightTime = new DateTime(2000, 1, 1, 0, 0, 0);

    string imageName = ImageOfTheDayService.GetImage(nightTime);
    Assert.AreEqual(imageName, "moon.jpg");
}

Note that I eliminated the dependency on the system clock by simply creating a DateTime that represents "night time". Another test creates a "day time" DateTime, and perhaps more to fill in edge cases. Instead of creating an interface to wrap something that didn't need fixing, we used DateTime exactly how they were designed. DateTime.Now is not the only way to create a DateTime object.

Solving a non-deterministic test with mocks only works when it's the component under test that has the non-deterministic dependencies. In the example AzamSharp's example, it was the test, and not the component that had the non-deterministic dependency. Creating the DateTime using its constructor led to both a more readable test and a more cohesive interface for the image service.

It's easy to believe everything is a nail if all you want to use is that shiny hammer. Keep in mind the purpose of mocks: to verify the indirect inputs and outputs of a component, not to fix every erratic test under the sun.

Ubuntu 8.04, VirtualBox, and USB support

Jason Meridth — Sun, 27 Apr 2008 16:42:00 GMT

UPDATE: Make sure your user account is a member of the vboxusers account. VirtualBox will not start and the error will tell you this, but just want to be explicit. You will have to logout and log back in.

I recently upgraded my Ubuntu to the latest version, as mentioned in a previous post. I'm very excited about it, due to greater support for hardware items that I've had to fight battles with (one of the many reasons people won't make the switch to Linux). I upgraded to Hardy Heron and then upgraded VirtualBox when prompted. It was a fatal hardware recognition mistake. As soon as I booted back up after a restart, I didn't have sound, wireless, etc.

After just not being in the mood of going down the road of trying to get the hardware re-recognized, I reloaded and di my research on the virtualbox upgrade. It seems to be a known issue on the ubuntuforms.

I looked through the forums and got educated on a few things about the ose (open source edition) versions of VirtualBox. 1. no usb support (I will update if I'm proved wrong). 2. the new ose kernel modules hose toshiba satellite hardware detection (at least on my laptop).

To get the gutsy non-ose version of Virtual Box, add this repository to /etc/apt/sources.list:

deb http://www.virtualbox.org/debian gutsy non-free

then in a terminal:

apt-get update
apt-get install virtualbox

if you get a host key issue, the do the following:

go get the public key.. go to this website and it'll have the key there just right click anywhere in the page and go to save page as then save it to your home directory preferably.

http://www.virtualbox.org/debian/innotek.asc

Now to add that key run...

apt-key add innotek.asc
apt-get update
apt-get install virtualbox

This will give you the gutsy version that I've worked with and have had no problems with. The bonus is that you get USB support.

I will get back to code posts next. Just want to share the knowledge with other Linux users.

MSDN - can't download with firefox

Jason Meridth — Sun, 27 Apr 2008 04:26:00 GMT

UPDATE: I'm on Linux. Getting this to work on Windows is simple enough, just like James mentions in the comments. Thanks.

I'm writing this, because it's about the 5th time I've had to use my Windows box or VM to get iso files from MSDN.

<rant>

I understand, in a business manner, why Microsoft won't allow downloads from Firefox at MSDN. I work for a company that was kind enough to give me a MSDN license. I've used it a great deal to get software like Vistual Studio 2008 and SQL Server 2008 recently. I also use it for the iso files I use in my VMs. I recently had to download Vista again and from Firefox the specific items I want (the checkboxes in MSDN's new Silverlight UI) are grayed out. COME ON!!!!!

I use Firefox more than I use Internet Explorer. And before, you non-Linux users tell me about the IE tab plugin for Firefox, let me remind you that you still have to have iexplore.exe on your PC. Linux doesn't have it (and shouldn't).

I like where Microsoft development teams are going recently (Guthrie, Haack, Conery, etc), but the MSDN team needs to wake up and open the ability to download items via Firefox.

If someone out there knows a way to do this with Firefox, I will update this post and eat some humble pie.

</rant>

Ubutnu 8.04 (Hardy Heron) after upgrade - I have complete sound!!

Jason Meridth — Sat, 26 Apr 2008 17:46:00 GMT

UPDATE: Do not upgrade your virtual box install. Stay with the Gutsy version if you already have it. If you are just installing Hardy Heron from scratch, I will have a post in a little bit and link to it here about how to ensure you get the correct version.

In a previous post, I shared the pain of getting sound working on my Toshiba Satellite laptop with prior versions of Ubuntu. It has been off and on for a while and I've even resorting to recompiling my kernel to get it to work (no luck). After upgrading to Hardy Heron today and restarting, I heard the wonderful drum sounds you here when Ubuntu loands. YIPEE!! I just logged in and finally got to watch some of the CodeBetter screencasts on the Seattle conference on my laptop without having to use my Windows VM. For some reason, when I plugged headphones in and used my Windows VM, I got sound.

I also got the latest beta of Firfox 3.0. Wow. My del.icio.us plugin was not compatible, but I did find the Shareaholic plugin that lets you post to Twitter, Facebook, Reddit, Digg, Del.icio.us, etc. Nice. A few special effects also.

I noticed that the OS also has indexing in place now, so you can search for programs like you do with Vista.

There are other new features that I'm excited about, but will use them in greater detail before I blog about them.

Don't get me wrong folks. Microsoft pays my bills with the day job, but I like Linux for personal reasons (oh and it's free). Just want to share in case anyone is thinking about switching or is currently using and hasn't upgraded. I finally got my Vista VM up and I'm working in IronPython again. I plan to post on that soon.

I'm just very happy my sound is working flawlessly.

Raising the bar

bogardj — Sat, 26 Apr 2008 04:34:44 GMT

Continuous improvement is absolutely essential for any serious software developer. Personally, my drive for constant improvement is not so much the next shiny developer toy (though this happens occasionally), but the idea that there is always some way to deliver value to the customer better and cheaper than what I'm doing now.

Driving personal improvement can be a great example to teammates, but for an entire team (or even teams you don't work with) to improve, you'll have to expand your horizons. You'll need to maximize the value of your keystrokes, so to speak.

So you sent an email to your teammates about a possible design improvement. Why not blog about it? So you read a new design or patterns book. Why not give your team a presentation and summary? So you refactored some gnarly code. Why not tell the whole team on your improvements?

Keeping self-improvement to your self might not improve your situation as much as you might like. Unless you're flying solo, other team members will eventually write code that you will despise.

Driving local improvement

Instead of deriding poor design, look towards collective improvement and raise your team's collective bar. Some different bar-raising techniques include:

Creating a team blog
Starting a book club
Hold brown-bag sessions on patterns, practices, refactorings, and others
Pairing and mentoring sessions with junior developers

If you're only improving yourself, your code will improve, but it won't impact the team's codebase as much as everyone's code improving. And it's not just code either. Communication and process improvements will provide at least, if not more value than coding improvements. Body language can tell you if you're on the right track when running ideas past your domain experts. If you can't recognize these signals, you're creating quite a bit of waste. Driving awareness and action of improvement areas are part of what's required of you to earn your pay.

Driving community improvement

Something I've made a personal commitment to do is to try and drive some community improvement. I'm already at a great place that expects XP practices, and we can always expand and improve, but every shop I run into has serious dysfunctions. I'd like to try to raise the bar through:

This blog and the literally tens of people that read it
Screencasts on ~~shiny new objects~~ values, principles and practices I think are important
Local book clubs
Skype/VNC sessions with interested folks (probably for a small fee)
Code camp sessions

I have my selfish reasons for these things, as everyone else's code is terrible. Except mine, of course. You can hear angels singing when I apply ReSharper shortcuts.

There are about an order of magnitude more bad developers than good ones, and another order of magnitude from good to great. The onus is on the upper-level practitioners to mentor others and raise the collective bar of our community.