Jay Harris is Cpt. LoadTest

a .net developers blog on improving user experience of humans and coders
Home | About | Speaking | Contact | Archives | RSS
Filed under: Events

Torn between attending Lansing Give Camp or the Kalamazoo X Conference?
You don't have to choose; do both!

Give Camp or X Conference?

The first ever Lansing Give Camp is being held April 24-26. The first ever Kalamazoo X Conference is being held April 25. The sessions of the X Conference offer a great opportunity for learning and for improving your craft. For $20, you can't beat that. But Lansing Give Camp is a weekend of giving back to the community by helping out local charities. Coding for a cause; you can't beat that, either. Two amazing events, slightly more than an hour from each other, are being held the same weekend. It's like a bad case of deadlocked threads. Kalamazoo or Lansing? Lansing or Kalamazoo? How do you choose between them?

You don't have to choose. Go to both.

Spend the weekend in Kalamazansing!

Kalamazoo X Conference and Lansing Give Camp have partnered together. Lansing Give Camp will have special projects that will accommodate X Conference attendees. Kalamazoo X Conference is waiving its registration fee for anyone attending Lansing Give Camp. Friday night, come out to Give Camp. Saturday morning you can grab a shower (thanks to a partnership with the Lansing YMCA), and head out to Kalamazoo. When the event is over, finish out the weekend back in Lansing, coding for a cause. It's almost like one big event, spread between two Michigan cities. Kalamazansing.

I want to go to Kalamazansing!

Sign up Lansing Give Camp at http://www.lansinggivecamp.org. The registration form includes an option to sign up for the X Conference, too. We'll take care of the rest.

Wednesday, April 8, 2009 4:55:41 PM (Eastern Daylight Time, UTC-04:00)  #    Comments [0] - Trackback

Filed under: Events

LansGiveCamp2009 On April 24th-26th, 2008, the local software development communities will pool their talents to put together the first ever Give Camp in Lansing Michigan. The event will be hosted at the Impression 5 Science Center in downtown Lansing. For more information, please visit the event's web site, http://www.lansinggivecamp.org.

Lansing Give Camp

April 24-26 at the Impression 5 Science Center
200 Museum Drive, Lansing, MI 48933

What is a Give Camp?

A Give Camp is a weekend-long event where software developers, designers, and database administrators donate their time to create custom software solutions for non-profit organizations. This custom software could be a new web site for the nonprofit organization, a small data-collection application to keep track of members, or an application for the Red Cross that automatically will email a blood donor three months after they've last donated blood to remind them that they are again eligible to donate blood. The only limitation for a Give Camp project is that it must be scoped to be completed within a weekend.

During the event, developers are welcome to come and go as they please. The event will continue 24/7 from Friday afternoon through Sunday afternoon, and developers can choose to go home in the evenings or camp out for the entire weekend. Showers are not available at the Impression 5 facility, but the Lansing YMCA--just down the street--is donating their facilities throughout the weekend for any Give Camp attendees.

How can I help?

If you are a developer and are interested in attending, please go to the event web site and register for the event. We are looking for developers of all skill levels to help out, from students to senior developers, and for developers of all skill sets, including designers, developers, database administrators, and more. If you can code, we want you there!

What about Sponsorship?

Lansing Give Camp is seeking cash donations of any amount, or the sponsorship of a meal. A meal sponsorship would entail funding breakfast, lunch, or dinner for roughly 100 volunteers. Typical meals would be sandwiches, pizza, or BBQ. As consideration for your donation, your organization’s logo will be added to the Give Camp web site, along with mention during the opening and closing sessions.

Technorati Tags: ,,
Wednesday, April 8, 2009 12:50:07 PM (Eastern Daylight Time, UTC-04:00)  #    Comments [0] - Trackback

Filed under: Blogging

FeedBurner used to allow adding DotNetKicks FeedFlare to your feeds. Even today, the FeedFlare catalog lists "Kick It" using DNK's FeedFlareUnit file. Unfortunately, when adding this file to FeedFlare using the link given in the catalog, the unfortunate user receives only a JavaScript alert of "We could not find a valid FeedFlare file at that location" instead of an enhanced feed. Why? No XML Declaration is contained within DNK's XML file.

Example XML Declaration

<?xml version="1.0" encoding="utf-8"?>

By adding only an XML Declaration to the top of the file, FeedBurner is now able to properly parse the document, and add the new flare to a feed. This would also apply to any custom FeedFlareUnit that you develop; be sure to add an XML Declaration to your XML.

Corrected File for DotNetKicks

Download: kickitflare.xml

<?xml version="1.0" encoding="utf-8"?>
    <Title>Kick it</Title>
    <Description>Kick this story on dotnetkicks.com</Description>
    <Text>Kick it</Text>
    <Link href="http://www.dotnetkicks.com/kick/?url=${link}" />

I have logged a ticket with DotNetKicks on their Google Code issue tracker. Hopefully, as opportunity allows, they can update the file on dotnetkicks.com so that the FeedFlare catalog entry will work once again. Feel free to add DotNetKicks FeedFlare to your FeedBurner feed using the file link above until they have an opportunity to address the ticket.

Adding DotNetKicks FeedFlare to your FeedBurner Feed

To add the "Kick It" FeedFlare to your existing FeedBurner feed:

  1. Copy the URL for the updated kickitflare.xml file to your clipboard:
  2. Log in to FeedBurner at http://feedburner.google.com
  3. Navigate to your feed details, then to the Optimize tab, then to FeedFlare
  4. Paste the URL into the textbox, and click Add New Flare.
  5. As desired, check the appropriate checkboxes to add the flare to your RSS feed and to your site.
  6. Click the Save button at the bottom of the page.
Thursday, April 2, 2009 8:07:41 AM (Eastern Standard Time, UTC-05:00)  #    Comments [0] - Trackback

Scheduled Integration is hard. I remember being involved in projects where developers would get a copy of the latest source code and a task, and race off like horses at the track while they spent a few weeks implementing their assigned feature. At the end of these many weeks was a scheduled integration, where all developers in the team would reconvene with their code modifications, and try to get their respective code to play well in a single sandbox. Project managers always seemed to expect that this would be a quick and painless process, but, of course, it never was. Reintegration of the code sometimes took just as long as the implementation, itself. Even if developers are all working in one big room throughout the project, the code remains isolated, never shared or reintegrated. Fortunately, Continuous Integration specifically focuses on this problem by reducing (and often eliminating) the end-of-project reintegration cycle through a continuous constant integration process.

Continuously Integrating your Mind

For a moment, compare  the process of software development with the process of learning new technologies in your field. In the past few years of Microsoft's .NET platform, we've seen .NET 2.0, Windows Communication Foundation, Windows Presentation Foundation, Workflow Foundation, Extension Methods, Generics, Linq, Dynamic Data, ASP.NET MVC, and more. For a developer that has not kept up with the latest trends, to suddenly and quickly catch up with the bleeding edge would be a major undertaking, and psychologically intimidating. This Scheduled Integration approach to learning can be overwhelming; the learning process is isolated, and only occasionally reconnects to the latest technologies. However, a developer that has kept up with the trends, learning through a continuous integration process, has been constantly updating, constantly learning the Next Big Thing over these past few years; this developer is already long familiar with .NET 2.0, WF, WCF, WPF, Generics, and Linq, and is now working on only Dynamic Data and MVC. The Continuous Integration process ensures that those involved are current with the latest developments in their project, and that the overwhelming burden of integration at the end of a project is instead simplified by distributing it throughout the course of the timeline.

Core Continuous Integration

At its core, Continuous Integration, or CI, is a development model where developers regularly commit and update against their source control repository. By committing (giving everyone else access to your code changes) and updating (getting code changes from everyone else), the scheduled, tedious integration process at the end of the project is eliminated. Added on top of this single fundamental, is ensuring the code works: Automating the build through scripting frameworks like Make, MSBuild, or NAnt helps developers validate their status quickly, by invoking a validation step that not only compiles, but executes a suite of unit tests against the code base. Validation results, along with the latest valid code, are then made easily accessible to anyone on the team.

The ten tenets of Continuous Integration are:

  1. Maintain a Source Code Repository
    Use a code repository, such as Subversion, Bazaar, or even Visual Source Safe. This allows a central point-of-truth for the development team, against which code can be committed or updated. This even applies to a development team consisting of only one person, as a local hard drive alone cannot provide change logs, revision differences, rollback capability, and other benefits of source management.
  2. Commit Frequently
    As other developers commit code changes, your local version of the code will get further and further from the revision head, thus increasing the likelihood of a conflicting change that will need manual resolution. By committing often (and by association, updating even more often), everyone can stay very close to the revision head, reducing the likelihood of conflicts, and reducing time to integrate code and functionality.
  3. Self-Testing Code
    "It compiles" is not sufficient criteria for determining if a project is ready for delivery or deployment to the client. Some level of testing must be conducted against each compile to measure application quality. Using unit tests, functional tests, or some other form of automated acceptance tests, the code can evaluate itself against expected outcome, providing a much more accurate and granular metric for readiness.
  4. Automate the Build
    Using Make, NAnt, MSBuild, or similar frameworks, consolidate execution of your full build into a single command, or a single icon on your desktop. These scripts should execute a full compile, and run your full suite of testing and evaluation tools against the compile.
  5. Build Fast, Fail Fast
    Even if your build is automated, no one wants to wait 30 minutes for the build to complete. Building your code should not just be a lunch-break activity. Keep the build fast to enable developers to do so as often as possible. And if there is a problem, fail immediately.
  6. Build Every Mainline Commit on an Integration Machine
    We all have applications on our local desktops that will not be present in Production. Instant Messenger, iTunes, Visual Studio, and Office are all common for us, but rare in Production. However, these applications can conflict or distort build results, such as a reference to an Office assembly that is not included in your deployment package. By executing the automated build on an integration machine (iTunes free, and using a CI suite like Hudson or CruiseControl), you can increase confidence in your application and eliminate "it works on my box!"
  7. Automate the Deployment
    Manual code deployment is a mundane, highly repetitive, error-prone, and time-consuming process that is ripe for automation. The time commitment adds to the stress when QA requests yet another deployment to the testing environment, particularly when all of the developers are in 80-hour-week crunch mode. In turn, this stress reduces deployment quality; environments often have configuration differences, such as different database connection strings, credentials, or web service URLs, and often only one configuration change needs to be overlooked to cause the entire system to malfunction. Automate this task, so that it can be executed easily, dependably, and often.
  8. Test in a Clone of the Production Environment
    In addition to Office and iTunes not being a part of the production server build, there are aspects of the production environment that are not a part of the desktop environment. Server farms, federated databases, and load balancing are examples of things that do not exist on the developer desktop, but do exist in production, and can cause surprises if they are not considered during development and testing. Consider the haves and the have-nots in your test environment, and eliminate these surprises. And if the cost of another production environment is out of reach, consider Virtual Machines. VMs have significantly reduced the cost of creating a watered down test environment that still has things like server farms or database clusters; even if you cannot exactly replicate your production configuration, mitigate your risk by reducing the differences between your test and production environments.
  9. Everyone Can View the Latest Build Results
    The underlying driver behind Continuous Integration is transparency and visibility. Communication enables both transparency and visibility by allowing everyone on the team to know the full status of the build. Did it compile? Did the unit tests pass? Which unit tests failed? Did the deployment work? How many seconds did it take to compile the application? Who broke the build? Continuous Integration suites, such as Hudson or CruiseControl, provide reporting mechanisms on build status. Make this status available to anyone, including project managers, and even the sales guy.
  10. Everyone Can Get the Latest Executable
    On a software development project, communication is more than just green icons (successful builds) and red icons (failed builds). Communicate the ones and zeros, in the form of your compiled application, to your team. By allowing other developers, testers, and even the sales guy (perhaps for a demo) to get the latest bits for themselves, developers can focus on writing code.

Benefits of Continuous Integration

By continuously integrating all new code and feature sets, development teams can eliminate that long and tedious scheduled integration effort, which reduces overall effort, time line, and budget. Through self-testing code and building every mainline commit, code is continuously tested against a full suite of tests, allowing quick analysis and identification of breaking changes. Through the easy accessibility of the latest bits, the team can test early and often, allowing quick identification of broken functionality, and for early identification of features that don't quite align with what the client had in mind. And finally, the immediate and public feedback on the success or failure of the build provides incentives for developers to write code in smaller increments and perform more pre-commit testing, resulting in higher quality code.

I consider Continuous Integration to be an essential, required part of any development effort, every time. I started using CI in 2004, and I have since become dependent on it. I even have a Continuous Integration box at home, validating home projects for my development-team-of-one, and I am comforted by having a Continuous Integration server analyzing and validating every code change that I make. I break unit tests as often as anyone else does, and there still continues to be plenty of times that I even break the compile. At least once, every developer among us has checked in the project file while forgetting to add myNewClass.cs to Source Control. It will break the compile every time. Fortunately, Continuous Integration is always watching my code commits; it will let me know that it could not find myNewClass.cs, every time. And my application's quality is remarkably better for it. Every time.

Wednesday, April 1, 2009 7:25:01 PM (Eastern Standard Time, UTC-05:00)  #    Comments [0] - Trackback