This blog has been moved to Redwerb.com.
I've moved my blog to www.redwerb.com (a domain I've had for awhile, but never got around to using).
I've managed to transfer all my posts to the new blog (though I've lost all my comments in the process). I plan on disabling my Blogger account soon, but I will probably leave the posts up for now.
If you are subscribing to the RSS feed, the new feed is http://feeds.feedburner.com/Redwerb.
Hopefully I will see you on my new site!
Over the last 20 years I have had many opportunities to observe my fellow motorists (especially since I started commuting 35 miles or to work everyday). During this time, I have noticed some very common patterns on the road. These patterns are often annoying and sometimes dangerous (though I'm sure we're all occasionally guilty of some of them).
So next time you are stuck in traffic, try to spot as many patterns as you can. If you know of any patterns that I missed or have a better name for one of my patterns, leave a comment.
The illustrations in this post are courtesy of the GT Challenge arcade game and my wicked Paint.Net skillz :).
Ever notice that anyone going slower than you is an idiot, but anyone going faster is a maniac? - George Carlin
Microsoft has just announced that they have "released an early preview of the Parallel Extensions to the .NET Framework (ParallelFX) technology." I haven't had a chance to check this out yet, but it looks like it will provide a new API for managing threading. What looks especially interesting are the multi-threaded foreach loops.
I don't want to say too much because I really don't know much about it, but check out the announcement on Somasegar's blog, Parallel Extensions to the .NET FX CTP.
As regular readers might already know, I am taking a certificate program in User-Centered Design. This quarter I am taking a class on usability testing.
One of the things I've learned in the course is that there seems to be a debate on qualitative vs. quantitative results. For the sake of this post, I'll define them as thus:
Qualitative - descriptive, subjective. Not easy to provide objective measurement.
Quantitative - numerical, objective. In sufficient quantity can provide statistically significant facts.
As you can probably imagine, most people would like to see quantitative results. They are easy to understand and see just how important a particular issue might be (not to mention those cool graphs). However, due to budget and time constraints, it is extremely uncommon for a usability test to have a sufficient number of participants to qualify for statistical significance. Without statistical significance, are quantitative results useful?
I have to say emphatically no. Quantitative results are completely useless within a usability test. The goal of usability testing should be to find flaws in the design (from the users perspective) of the software. These flaws should be tracked and prioritized the same as any other defect within the application (hopefully you use issue/bug tracking software).
Usability testing should focus on qualitative feedback. There are many techniques that you can use to elicit feedback from a user (for example, thinking out loud). Post study questionnaires can also be useful, but the questions should be open ended. You can ask a participant to rate the software, but only to lead them to the next question which should ask why they rated it the way they did (the actual rating is useless without statistical significance).
Furthermore, when reporting the results of usability tests, it is important not to imply any kind of statistical significance. For example, don't say that 20% of the participants failed to complete a task when you only had five participants. For all you know, that participant is the only person on the planet that would fail or perhaps the other four just got lucky. Even mentioning something like 1 out of 5 can be dangerous. Always make sure that people that are reading your report understand the limitations of the data.
This just in, Microsoft has shipped Visual Studio 2008! Read Somasegar's Weblog for the official announcement.
I can't wait to try it out. I'm looking forward to trying out all the new features such as XML literals in VB.Net, improved Intellisense, LINQ, integrated unit testing, and much more.
Hopefully I will get a chance to purchase a copy from the MS store soon. Are there any MS employees reading this that wouldn't mind if I bought this on their quota? I don't work too far from Redmond :).
The Commonly Used Types and Namespaces poster for version 3.5 of the .Net framework is now available.
It main sections are Windows Presentation Foundation/Windows Forms (in green), ASP.NET (in yellow), Communications and Workflow (in orange), Data, XML and LINQ (in purple), and Fundamental (in blue).
The poster lists new types as well as what will be available in the 3.5 version of the compact framework and Silverlight 1.1.
There is a lot of new stuff in here. Here is a quick list of what's new in each section:
I found the add-in support particularly interesting. I have been planning on implementing add-ins for the next major version of our product and am hoping to be able to use the add-in support in .Net 3.5. If you are interesting in finding out more about this, check out the article .NET Application Extensibility and the CLR Add-In Team Blog.
Jeff Atwood had a great post today about automating your build process (The F5 Key Is Not a Build Process) and it inspired me to finally write this post (I promised it a while ago - Making the Build).
As mentioned in my post Making the Build, an automated build process is very important. However, most software teams have a tight schedule and budget and find it difficult to justify spending time creating a proper build process, especially when nobody on the team has previous experience creating an automated build process.
Before I get to the benefits of an automated build, let me first describe the build for our product.
Our build process is fully automated. We have it scheduled to run on a dedicated machine every night. The build includes many different things, including compiling the source code, building the database from the previous version of our product using scripts, generating some source code, updating assembly attributes (such as version, company, etc), running unit tests, and more (too project specific to bother mentioning).
The benefits that we have found for our team are as follows:
If you decide to create an automated build process, here are a few suggestions (some of the advice is specific to building .Net projects, but I think much of it should hold true for other technologies as well):
Many people also advocate that build should be able to be run by any developer on their machine. This hasn't been very realistic for our project due to the size of the project and the cost of the software we chose to use (FinalBuilder isn't exactly free). However, it is a goal that I approve of.
If your project doesn't currently have an automated build process, I hope this article has encouraged you to create one. Good luck.
Regular readers of my blog have probably noticed that my blogging schedule has been a bit erratic lately (not that I've ever stuck to a strict schedule :). Unfortunately I haven't had much free time lately.
I've started taking classes to obtain a certificate in usability from the University of Washington. At work I recently gave a presentation at a user conference and I'm rewriting the UI framework that our company uses. And my family has taken up some time as well with football, birthdays, etc.
However, I do plan to keep my blog going and will try to fit some short posts into my schedule on occasion. Who knows, maybe someday my writing will improve enough where I have Jeff Atwood's (from Coding Horror) problems.
On another note, what types of articles would you like to see?
My most popular post is Data Binding Classes, Interfaces, and Attributes in Windows Forms 2.0. This post is even more popular than my main page. Perhaps I should write more articles focused on the .Net UI. This is my area of expertise. Perhaps I could write articles on design-time support for Visual Studio? I am certainly aware that this is an area that needs more documentation.
Of course I am also starting to focus more on usability at my work and I'm taking the certificate program. Perhaps I should write more articles that discuss this topic?
What about other topics? Business of software? Cool technology? Developer productivity? Others? I would love to hear from you and get your opinion!
I would especially like to hear from you if you read my blog in an RSS reader. I do not believe that the analytical software that I use (Google Analytics and StatCounter) tracks RSS feeds. So I have no idea if anybody is reading my blog through an RSS reader. Just a "Hi, I read your blog through an RSS feed" would do fine :).
Have you heard of Seam Carving before? Seam Carving allows you to stretch or squish images without distorting them. It's an amazing process that you have to see to believe. The video is just a little over 4 minutes and well worth it (even my wife thought it was cool, though she might have just been pretending).
I learned of this through a blog post by Mike Swanson. He has created a .Net version of this algorithm. I'm really hoping that this makes its way into Paint.Net!
For more details about Seam Carving, check out Seam carving for content-aware image resizing [20 MB PDF].
Microsoft has announced plans to release the source code for the .Net framework (comments and all!). This is awesome news for those of us that stress the framework fairly regularly.
Of course, Reflector gave us the ability to view the code already, but now you will be able to view the source code comments as well as step into the code with VS 2008. In fact, with VS 2008, if you don't already have the source code and you attempt to step into it, it will prompt you to download it automatically.
It's not quite open source, but it's still a big step for Microsoft. VS 2008 is certainly looking like it will be an interesting release! Hopefully it will be ready by the end of the year (please don't make me wait too long!:).
I am now officially registered for the University of Washington User-Centered Design certificate program (UCD from here on). I'll be starting classes in October and should finish the program in the Spring (3 quarters). The company I work for offered to pay for training so I readily accepted. I was a bit worried that this would be too much for the budget ($1,800 a quarter for 3 quarters), but I don't think many others in the department are doing much.
The last certificate program I took at the UW (Object-Oriented Analysis and Design Using UML) took almost a year and a half to complete (I was definitely ready to be done with it by the end). It was all done online (except for a single trip to a testing facility for a written test). Being online was convenient, but I did miss the interaction with other students and the professors.
The UCD program, by contrast, is being held in classrooms, once a week, in the evening. Luckily I was able to arrange to take the first of the classes in Bellevue which isn't too far from Kirkland where I work (hopefully traffic won't be a major problem). Unfortunately the rest of the classes are going to be in Seattle, so that will suck trying to get over to the campus during rush-hour traffic.
I was hoping I could find a program at the UW Bothell. It's only a few minutes from my work and is where I received my bachelors degree (Computing and Software Systems). Unfortunately they don't seem to offer any certificate programs, though maybe I'll get an MBA from there once the kids are out of the house (though their might be a branch campus near where I live by then).
I am hoping that this usability program that I am taking will provide me with plenty of material for my blog. If you are interested in this subject and don't want to spend the time or money on the course, stay tuned.
Before you can design an interface that is easy-to-use, you must first know something about the user and how they plan on using the interface. Unless you are building an interface for only yourself, it is unlikely that you will get it right without actually talking to potential users.
So what characteristics are important when designing an interface? Although this list might change based on the interface you are designing, for a line-of-business application, the important characteristics tend to be...
As you can imagine, if you are planning on your interface being used by many people, you will probably need to talk to many potential users to get a reasonable understanding of what is common (though if you only talk to a single individual that would still probably be better than having a software developer guess).
So how do you compile this information? Once you've interviewed the users, you can use the information to put together a user profile that includes all of the common and important user characteristics. Persona's have become a common technique for building this profile. A persona is basically a fictional character that you create that typifies the target user. The reason that many people use personas is that it makes it easy to discuss requirements by just mentioning the persona's name.
Example conversation between two interface designers:
[John] Hey Sally, what do you think of this form I'm designing?
[Sally] Who's it for?
[John] Frank [persona] is going to be using it.
[Sally] It looks good except for that link. I don't think Frank will be able to use it. He's been working with those chemicals for years and would never be able to get the mouse to hover over it. You should make it larger.
As long as both designers agree on the persona, John can immediately see that Sally is right and they can avoid all the discussion usually accompanied by such criticism. Of course, the main power of personas is that John's interface is already mostly correct with no discussion necessary.
One of the best examples of personas I've found on the Internet is from Microsoft. The Dynamics team has put together an excellent list of personas for their product and have made a couple of those personas available on the Internet. Microsoft Dynamics RoleTailored Business Productivity whitepaper
Ok, not really, but I got my Evil Mastermind t-shirt from Source Gear. The payment was that I had to post a picture of myself wearing it. I don't really like getting my picture taken, so I created this picture instead (hopefully it's good enough).
If you want the full story for the picture, read the Evil Mastermind comic book.
The picture of me was created with the Simpsonizer. I added the Evil Mastermind image and the text using Paint.Net.
Source Gear (the company that sent me this t-shirt) is run by Eric Sink. Eric has also written a book called Eric Sink on the Business of Software, coined the term Micro-ISV, and has a great blog that I read regularly.
Microsoft is making some great improvements to Intellisense for Visual Basic .Net in Visual Studio 2008. Most of the new features are based around the language enhancements for VB 9, such as LINQ, anonymous types, etc. Though there are many other improvements as well.
There are many other improvements as well. If you are interested in learning more, check out this Ch 9 video: Visual Basic Intellisense Improvements in VS 2008.
Keep It Simple, Stupid, or the way I like to phrase it, make the simple things simple and the complex things possible. This is a very common design mistake. Users ask for tons of features and developers work hard at delivering those features, but often times at the expense of a simple to use application.
Of course by simple, I mean "everything should be made as simple as possible, but no simpler" (quote attributed to Albert Einstein). If the interface doesn't make the most common way of performing a task as simple as possible, the interface has failed the user.
An example for good use of this principle is the Remote Desktop connection interface. When you start Remote Desktop, you see a UI with the absolute bare minimum interface for connecting to another computer (figure 1), a single textbox for entering the name of the computer you want to connect to and some buttons to perform what should be easy to understand commands (at least, easy to understand if you know what the application is supposed to do in the first place).
Figure 1: Simple interface for Remote Desktop.
Of course there are a lot of options that you might want to change when connecting to another computer, if you are an advanced user with a special need you can select the Options >> button. This button opens another window (figure 2) that allows you to change the advanced settings of Remote Desktop, you can even save the settings so that you don't need to go through the options dialog again.
Figure 2: Complex interface for Remote Desktop.
The term for this type of interface is progressive disclosure which simply means removing less frequently used interface elements from the primary screen while still providing a means of accessing those elements. This can be in the form of a secondary screen, such as in Remote Desktop, collapsing regions, or providing an Advanced tab within a tabbed interface (this can be seen in the options dialog in the Remote Desktop screenshot, figure 2).
If you want to see how not to design a UI, take a look at Bulk Rename Utility (figure 3). It seems to provide every possible option on the main form, regardless of how often it is used. Bulk Rename Utility is a useful tool intended for computer savvy people who can probably overlook a bad UI if it provides the features they need, but you would never want to put a UI like this in front of a technophobe.
Figure 3: Overly complex interface for Bulk Rename Utility.
So how do you know what the simplest interface is for the user? Asking the users is certainly a good start, though not entirely reliable (the mind has a tendency to assign equal importance to exceptional cases and common ones). Other methods include watching the user actually performing the task and logging feature usage and analyzing the results. Feature logging will probably result in the most comprehensive and accurate view of the current system, but it requires you to have a system in place already and for your users to be willing to share the information that is being logged.
By keeping the interface as simple as possible, the user is able to accomplish the task quicker with higher accuracy, less training, and fewer support calls. By providing a simple interface with the ability to perform more complex tasks you have taken nothing away from the user except a barrier to using the application.
One of my favorite usability rules is "consistency is more important than correctness." Just to be clear, this is not intended to diminish the importance of correctness, it simply means that if you can't be correct everywhere, you should at least be consistent. Consistency can help lower training costs and reduce mistakes.
As an example of this rule, let's take a complex application with many forms. Dates are displayed on many of these forms using a hard coded format of Month/Day/Year. You have been tasked to create a new form. As a good, conscientious developer, you know that dates should be formatted differently based on the culture of the user and that there is a built in function for formatting the date that actually requires less effort on your part than formatting the date yourself.
What should you do?
Of course, the best answer is C, fix all the other places in the application where the date is formatted incorrectly. Unfortunately, that's not an option you. You don't have access to the other source code, there is business logic relying on the date format, nobody has reported it as a problem before, there is not enough time to fix it, we don't have the testing resources to test in different cultures, etc. (I'm sure you have heard plenty of reasons why people don't want to fix incorrect code).
The second best option is B, format the date consistently with all the other dates in the system. If all the dates are formatted wrong and the user is forced to use the software, they will eventually learn how the date is formatted and will expect the date to always be formatted that way. If their culture reverses the month and day (Day/Month/Year) the user may not realize that you are formatting it correctly and read the date incorrectly possibly causing costly mistakes (a customer doesn't get charged for 6 months, the company's domain name expires, a patient doesn't get scheduled for treatment soon enough and dies, etc.).
Of course, data formatting is not the only thing that should be consistent. Here is a list of common things to look for...
Summertime has really effected my blogging schedule. I've been spending my freetime working on a website for my neighborhood and building a garden wall. I'm almost done with the wall, but we might end up extending it another 30 feet, so we'll see.
Just recently I've started using a tool called SlickRun. It's a very simple tool that is essentially just a textbox (no form, buttons, etc). It allows you to type in commands similar to the Run (Win+R) dialog built into Windows. The cool thing about SlickRun however, is that you can also add "MagicWords" to it so that you can perform more complex commands with a single word.
There are plenty of configuration options for SlickRun to get it to look and work the way you want (see the screenshot to the right). You can even setup SlickRun to run instead of the Windows Run dialog. This is a little tricky since you have to edit the config file (I'm not sure why this setting isn't in the SlickRun config dialog), but once you set it up, when you press Win+R you get SlickRun!
Last day of the workshop went well. I'll be sad to leave the prepared lunches, snacks, ice cream, etc at Microsoft, but I won't be sad to leave those horrible chairs (my back is killing me).
Most of today was on Microsoft Office integration with a short bit at the end for Team System. I left a few minutes early hoping to avoid the traffic on my way home, unfortunately my plan didn't work out that well (2 hours!).
Office Integration
Visual Studio Team System
PowerPoint Presentation
I downloaded the PowerPoint presentations from the workshop. If you would like me to email you one, just mention which one you want and leave your email address. I don't feel comfortable just putting them on the Internet, but I don't see why Microsoft would care if I shared them (they said it was ok to download them and there wasn't any NDA that I remember anyway). If you want one, please note that they were built with PowerPoint 2007. If you don't have PowerPoint 2007 you will need to download a 28MB Office Compatibility pack.
Well, this ends my Visual Studio 2008 and .Net Framework 3.5 Workshop journal. I hope you enjoyed it. I'm excited to see the final release of VS 2008.
Three days down, one to go. There was a great presentation on WCF (Windows Communication Foundation) today! I'm really impressed with some of the stuff they provide out of the box for free. They also talked about WF (WorkFlow) and mobile devices.
WCF
WF
I didn't find this presentation as interesting because I already know something about it and it doesn't look like they are adding much for 3.5.
Mobile Apps
There seems to be a lot of cool new features for mobile devices within the Orcas time frame, especially for developers.
Compact Framework
Another busy day, at the Visual Studio "Orcas" and .NET Framework 3.5 Training Workshop. The first topic was a very high level roadmap of the different Microsoft technologies that are available or are coming available within the next year or so (ASP.Net 2.0, ASP.Net 3.5, Silverlight 1.0, Silverlight 1.1, WPF 3.0, WPF 3.5, etc). I'm not sure who the prime demographic was for this presentation, but I find it hard to believe it was too many people in the room. All the information was already well known to everybody in the room (either because they knew it coming into the conference or because it was discussed yesterday at the conference).
The presentation I found the most interesting today was the one on ASP.Net 3.5. I've listed some of the interesting things I learned today about it below.
New Features for ASP.Net 3.5
Even though I don't work with ASP.Net professionally (at least, not much), I do work with it personally (I've volunteered to maintain my communities website which I am switching to ASP.Net 2.0 tonight!). So I was pretty interested in this topic. It's also important to keep up with this stuff since the Internet is not going away, in fact, it's more likely that desktop development will go away that browser-based development (though I won't be holding my breath for that).
Silverlight
I'm not sure if I will be able to make use of this technology, but it's certainly interesting for it's own sake and who knows, this could become the future of browser based development.
WPF
Blah blah blah. This is a technology that seems very important, but I just haven't been able to get excited about it yet. It's such a huge paradigm shift and there just isn't enough tool support, 3rd party controls, or compelling features available to make this feasible for a large scale, line-of-business application (which is what I write at work). As a developer I would love to dive into this technology, but as a professional, I've got to consider how this will effect the company I work for and the customers we serve. Unfortunately, this means I cannot commit to the time it will take to learn this.
What this means for you is that I tuned out for a large portion of this talk and so my notes are fairly sparse (I've been through it all before anyway at a previous conference that went into way more depth). But what I paid attention to I will share :).
I have completed day one of the Visual Studio "Orcas" and .NET Framework 3.5 Training Workshop. Today included a great overview of many of the new language features coming in this release. Unfortunately there wasn't enough time to go over all of the new features, but the features that I saw, I like.
Perhaps the defining feature of .Net 3.5 is LINQ (I haven't figured out the "official" way of pronouncing this yet, but I heard it pronounced as link at the workshop today). LINQ stands for Language INtegrated Query and is basically just that. LINQ allows for a developer to query any IEnumerable data source using a strongly typed, compiler validated, and Intellisense enabled syntax. If you are familiar with T-SQL, you will probably be comfortable with LINQ. The biggest difference between T-SQL and LINQ is that a LINQ query starts with the From keyword. There are also numerous other differences, however, given the Intellisense, they are easily discoverable (IMHO, one of the most important aspects of any API).
[UPDATE 06/26/2007]I forgot to mention a couple of things yesterday. According to one of the speakers, the primary performance goal of LINQ is to be as good as a for loop. However, there was a mention of a team working on a divide-and-conquer algorithm that will make it far faster on multi-proc/core machines. At this point it's just research. There is no date for release and there is a possibility that it won't get released. I should also have mentioned that there appear to be many different implementations of LINQ, there is LINQ for SQL (DLinq), LINQ for Entities (Entity Data Model), LINQ for XML (XLinq), and LINQ for Objects. There might be others as well. I'm not entirely sure of all of the terminology or how they are all used.[/UPDATE]
It appears that C# and VB.Net have widely differing capabilities in regards to LINQ. They both support a basic set of LINQ features, but VB.Net has a lot of keywords that are not available with C#. Many of these differences are based on the philosophy of each language team, but I imagine that developers will eventually demand (and hopefully get) features that one language supports that the other does not.
I thought the C++ section was going to be more interesting than it actually was (if you read my previous post about this conference you would know that I didn't think it was going to be that interesting :). I pretty much surfed the Internet the whole time and didn't get anything interesting out of it (sorry for anybody that is interested in the new improvements for C++).
However, I did pay rapt attention to the new language features for C# 3.0 and VB.Net 9.0. Most of the new features either directly support LINQ or are necessary to enable LINQ but can be used for other things as well. One of the cool things about the latter set of language enhancements is that they seem to be backwards compatible with .Net 2.0, so if you use Visual Studio 2008 to create .Net 2.0 applications using the built in ability to target different versions of the .Net framework, you can use some of the new language features!
Below I have included a list of some of the features that I found interesting. Unfortunately, given how quickly the speakers went over these features, I do not fully understand some of them, so if you find something interesting, you might want to look into it further just to make sure I'm not completely wrong about it ;).
New Language Features for C# 3.0
foreach(var cus in customers) // cus is strongly typed as a Customer type.
var cus = new Customer() { Name = "Boeing" };
public string Name { get; set;} // this is expanded by the compiler to be a standard property with corresponding field
public static string DoSomething(this string s) // This can be called like this - var something = "Hi".DoSomething()
New Language Features for VB.Net 9.0
Dim myXml = <People><Person><%= person.FirstName %></Person></People> ' Example of using XML as a native feature in VB
Imports <xmlns:ss="urn:schemas-microsoft-com:office:spreadsheet">
I've posted a new article on Code Project. It is titled Compiling Multiple Projects Without a Solution. The article shows how to compile a multi-project application without using solution files (yes, it includes source code).
The code creates a MSBuild project file that will allow MSBuild to compile a list of VB.Net or C# projects in the correct order. The list can be loaded based on a root directory that contains .vbproj and/or .csproj files or a text file that can contain a combination of directories, project files, and/or other text files.
I was invited to the Visual Studio "Orcas" and .NET Framework 3.5 Training Workshop at Microsoft next week (June 25th through June 28th). I'm pretty excited about going, it looks like a high level overview of all the major new features of VS 2008 and .Net 3.5.
I included the agenda for the workshop below (hopefully that's ok with MS, it doesn't say anywhere that I can't share it). I'm most looking forward to .NET Language Integrated Query (LINQ), What’s new in Visual Basic 9.0?, Introduction to Silverlight, Integrating Office & line of business systems using VSTO, and the Company Store Visit, though all the sessions look interesting other than maybe the one on C++ (I am beginning to think I will never program in that language again).
| Day | Start | End | Session |
| Monday, June 25 | 8:00 | 9:00 | Registration & Breakfast |
| 9:00 | 9:15 | Welcome & Introductions | |
| 9:15 | 10:00 | Lap around Visual Studio 2008 & .NET Framework 3.5 | |
| 10:00 | 11:00 | .NET Language Integrated Query (LINQ) | |
| 11:00 | 12:00 | Using LINQ with relational data | |
| 12:00 | 1:00 | Lunch | |
| 1:00 | 2:00 | Hands-on lab: LINQ | |
| 2:15 | 3:15 | What’s new in C# 3.0? | |
| 3:30 | 4:30 | What’s new in Visual Basic 9.0? | |
| 4:45 | 5:45 | What’s new in C++ 9.0? | |
| Tuesday, June 26 | 8:30 | 9:00 | Breakfast |
| 9:00 | 9:30 | Introduction to the Microsoft Client Continuum | |
| 9:45 | 11:00 | Building Web Applications with Visual Studio 2008 and the .NET Framework 3.5 | |
| 11:15 | 12:30 | Introduction to Silverlight | |
| 12:30 | 1:30 | Lunch | |
| 1:30 | 2:30 | Essential Windows Presentation Foundation | |
| 2:45 | 4:00 | Building Smart Client Applications with Visual Studio 2008 and the .NET Framework 3.5 using WPF and “Cider” | |
| 4:00 | 5:30 | Hands-on lab | |
| 5:30 | 7:30 | Evening Event: Barbeque at building 20 | |
| Wednesday, June 27 | 8:30 | 9:00 | Breakfast |
| 9:00 | 10:15 | Building WCF and WF Applications with the .NET Framework 3.5 | |
| 10:30 | 12:00 | Web Programming with WCF | |
| 12:00 | 1:00 | Lunch | |
| 1:00 | 2:15 | Workflow Services | |
| 2:15 | 3:30 | Hands-on lab | |
| 3:30 | 5:00 | Building Mobile Applications using Visual Studio 2008 and the .NET Compact Framework 3.5 | |
| 5:00 | 6:00 | Company Store Visit | |
| Thursday, June 28 | 8:30 | 9:00 | Breakfast |
| 9:00 | 10:00 | Overview of Office Business Applications and VSTO | |
| 10:15 | 11:30 | Extending the Office Fluent UI using VSTO | |
| 11:30 | 12:00 | Hands-on lab | |
| 12:00 | 1:00 | Lunch | |
| 1:00 | 2:30 | Integrating Office & line of business systems using VSTO | |
| 2:45 | 3:45 | Hands-on lab | |
| 3:45 | 5:00 | What’s new in Visual Studio Team System 2008? |
I am of the belief that an automated build process is perhaps the most essential element in producing a quality software application. The build process can be used to enforce good practices within the development team and also detect any issues within the application in a timely manner (the sooner you know about a problem, the less code you have to look at to determine what caused it). Even a small team with a simple application can benefit from an automated build process.
Recently I've gotten the opportunity to recreate the build process for the company I work for. The product is over 5 years old, is fairly large and complex (well over 200 separate .Net projects as well as database and legacy code), and has grown a fairly complicated build process using a combination of batch files and custom executables.
The main reason for recreating the build process is due to the difficulty of maintaining it. There were quite a few batch files and it wasn't easy to run. We averaged a build about once a week (builds should be run several times a day, nightly at most) and the unit tests weren't run very often and if they were, the results often times weren't published (it could be months before you find out a unit test no longer works and then who knows what changed that broke it).
I started building my own build software using Windows Workflow (see my April 28th post, Windows Workflow and Your Next Build System). Although it probably could work and is a great way to learn Windows Workflow, I soon remembered one of my life rules, always use the right tool for the job.
I decided to try FinalBuilder instead and boy am I glad I did. FinalBuilder (FB from here on) is a great build tool. They have dozens (maybe hundreds) of different actions (that's what they call activities or tasks) available to use, such as MSBuild, get from VSS, run SQL, update AssemblyInfo, NUnit, send email, etc. They also allow you to write script (either VBScript or JavaScript) that is run during the build. If that isn't enough for you, you can also create your own custom actions using .Net (or other supported languages).
I've looked at several of the build tools available out there today (especially the free ones :) such as MSBuild and NAnt and the thing that strikes me about these tools is that they seem to be designed for full time build engineers. I don't have time to figure out how to setup these tools let alone write a complete build process using them. Perhaps even more frustrating is that I actually did take the time to learn MSBuild at one point and had done some interesting things with it, however, I couldn't tell you the first thing about MSBuild anymore. I wouldn't use MSBuild to create an entire build process for the same reason I wouldn't use Perl to write an entire ERP system (write only code doesn't work well in a complex, constantly evolving product).
I am not sure if it would have taken longer to create the build process using another technology (such as MSBuild or batch files) or not, but the big benefit in using FB is in the ability to maintain it months later and, if I'm lucky, by somebody other than myself (I definitely don't want to be the "build" guy).
I'm sure there are other great build tools out there. If you know of one, feel free to leave a comment (I always love to find out about new tools :). I plan on writing another article within the next week or two that has more concrete tips for creating a build process (perhaps even some source code), so stay tuned.
