Posted by Dan Vanderboom on October 30, 2009
By request, I’ve made available the source code to my Wii remote controlled pan-tilt camera system using Phidgets components. See my original article here.
Warning: It’s messy in there. Don’t look to this as a good example of how robotics applications should be developed. There are far better patterns and libraries to use. This was merely my “get it up and running as quickly as possible” approach, to prove out the concept of getting all of the components to work together correctly.
Enjoy!
Posted in Uncategorized | Leave a Comment »
Posted by Dan Vanderboom on September 22, 2009
This morning, after being awoken at 5:30am by a rooster living nearby, I went for a walk to the northern tip of the island where beautiful homes are surrounded by lush tropical flowers and various palm trees, ferns, and cacti. Clouds with serious character muddied the early morning sky, and large birds hovered playfully in the air above the beautiful homes on J. E. Irasquin Blvd—not covering any ground, simply enjoying the feeling of the strong ocean wind, gliding without effort or purpose, hovering in place just above the tallest trees.
It’s surprising to me that humans consider such aimless delight a luxury. I’m in Aruba for the month September in part because I disagree; I think from time to time, it’s an absolute necessity to stay sane and keep a healthy perspective and sense of balance. When so many of our moments are goal-directed and serious, and as Americans we have less time off work than virtually every country on Earth, it’s only a matter of time before the intelligence of our own bodies revolts against us in protest, a petition against the undue stress and unrealistic expectations we often have of ourselves.
An hour later, I was following the winding road past Arushi beach, onto the part of Aruba that isn’t polluted much by light at night, where you can see thousands of stars and galaxies and the colorful dust of the Milky Way. The road curves back and forth several times and climbs steeply toward the California Lighthouse where I normally turn around and head back. Except today, to my surprise, I came across a herd of goats!
I first spotted them on the road and let them cross in front of me. A baby lagged behind, and I followed as closely as possible to get some better pictures. When I got within 20 feet, the little one bolted ahead, sprinting over ground that was treacherously uneven volcanic rock. The goats didn’t seem to have any problem running over this terrain, however, nor did they seem to mind me following them around for a half hour. Here you can see the little one in mid stride of a dashing pace, and notice how well it blends in with the ground’s color. I also enjoy seeing all the lizards here. I’ve seen several kinds and most of them are small, but this large one was hanging out at the Raddisson hotel by the pool.
I had the pleasure of going to a huge DJ party called something like Maj 4 Stix. The DJ rig was enormous, with thick outdoor smoke effects, blasts of fire and bright lights of every color, and thumping dance music. There were acrobats running in translucent plastic balls in the water that surrounded the dance stage like a moat, and hundreds of people dancing to really great music.
Every few days, I head to Oranjestad to work: the capital of Aruba. The best shopping seems to be there, since that’s where the cruise ships stop. The pictures below are of a shopping area in Oranjestad, and a church and graveyard in Noord where many people are buried in elaborate above-ground stone tombs.
Finally, here are two pictures of me: one in front of the rock waterfalls at the Raddisson Hotel from a video I made to wish my niece Ava a happy birthday, and a fun picture of me at Confession Club in Palm Beach.
I’ve hiked through the unpopulated countryside of Aruba; I’ve gone to the big parties and night clubs, spent a lot of time tanning on the beaches, enjoyed Dutch food (Cafe Rembrandt is my favorite), and went on a Jeep tour (through ABC Tours) to the natural pools, the gold mine buildings, and the old Indian-painted caves; and somehow have still managed to be very productive writing software for my current client as well as some personal projects I have in the works. I don’t often give advice, but I would definitely recommend enjoying life as much as possible while it lasts. Travel, work remotely, start a business, or do whatever makes sense in your life to follow your dreams, but don’t wait to do it!
Posted in Aruba | 3 Comments »
Posted by Dan Vanderboom on September 19, 2009
The Managed Extensibility Framework (MEF) is the new extensibility framework from Microsoft. Pioneered by Glenn Block in the patterns & practices group, and leveraged by the behemoth Visual Studio 2010, it has a striking resemblance to my own Inversion of Control (IoC) and Dependency Injection (DI) framework—which led to me to have a couple great conversations about IoC with Glenn at Tech Ed 2008 and then again at PDC 2008.
But MEF isn’t really written to be your IoC. Instead, the IoC engine and DI aspects are implementation details, allowing you to do really no more than “MEF things together”. The core concept of MEF is to provide very simple and powerful application composability. Not in the user interface composition sense—for that, see Prism for WPF and Silverlight (explained in MSDN Magazine, September 2008)—but for virtually all other dynamic component assembly needs, MEF is your best friend.
The two things I like most about MEF is its simplicity as its lack of presumption on how it will be used. Compose collections of strings, single method delegates, or implementations of complex services. All you’re doing is importing and exporting things, with little code required to wire things up.
MEF is currently in its seventh preview release, so expect beta-like quality. My own experience with it has been very positive, but there are a number of shortcomings in the API. This article is about a few of them and what can be done to add some much-needed functionality.
There’s been some confusion with Microsoft coopetition among products with similar aims, and extensibility and composition are no exception. The AddIn API (team blog) serves a similar purpose as MEF. (See this two-part MSDN article on System.AddIn: first and second.) The primary differentiator, from my understanding, is that the AddIn API is a bit more robust and a lot more complicated, and supports such things as isolating extensions in separate AppDomains.
With Visual Studio siding with MEF, it’s personally hard for me to imagine using the AddIn API. If MEF is flexible and robust enough for Visual Studio, is it really likely to fall short for my own much smaller software systems? Krzysztof Cwalina suggests they are complementary approaches, but I find that hard to swallow. Why would I want to use two different extensibility frameworks instead of one coherent API? If anything, I imagine that the lessons learned from the AddIn API will eventually migrate to MEF.
Daniel Moth notes that with the AddIn API, “there are many design decisions to make and quite a few subtleties in implementing those decisions in particular when it comes to discovering addins, version resiliency, isolation from the host etc.” A customer of mine using the AddIn API was using a Visual Studio plug-in to manage pipelines, and things were a real mess. There were a bunch of assemblies, a lot of generated code, and not much clarity or confidence that it was all really necessary.
In MEF, the Import attribute allows you to inject a value that is exported somewhere else using the Export attribute—typically from another assembly. There is also an ImportMany attribute which is useful when you expect several exports that use the same contract. By defining an IEnumerable<T> field or property and decorating it with the ImportMany attribute, all matching exports will be added to an enumerable type.
[ImportMany] public IEnumerable<IVehicle> Vehicles;
What if you want to filter the exported vehicle types by some kind of metadata, though? Let’s take a look at the IVehicle contract and some concrete classes that implement the contract.
public interface IVehicle { } [Export(typeof(IVehicle))] [ExportMetadata("Speed", "Slow")] public class ToyotaPrius : IVehicle { public ToyotaPrius() { } } [Export(typeof(IVehicle))] [ExportMetadata("Speed", "Fast")] public class LamborghiniDiablo : IVehicle { public LamborghiniDiablo() { } }
The object model isn’t very interesting, but that’s not the point. What is interesting is that MEF allows us to supply metadata corresponding to our exports. In this case, my contrived example has defined a metadata variable of “Speed”, with two possible values: “Fast” and “Slow”. The variable name must be a string, but its value can be any value; that is, any value that’s supported from within an attribute, which means string literals and constants, type objects, and the like.
What if you want to ImportMany for all exports that have a particular metadata value? Unfortunately, there are no such options in the ImportMany attribute class.
In my scenario, I’ve defined a static factory class called VehicleFactory, which at some imaginary point in the future will be responsible for building a city full of trafic.
public static class TrafficFactory { // type initialization fails without a static constructor static TrafficFactory() { } public static IEnumerable<IVehicle> SlowVehicles = App.Container.GetExportedValues<IVehicle>(metadata => metadata.ContainsKeyWithValue("Speed", "Slow")); public static IEnumerable<IVehicle> FastVehicles = App.Container.GetExportedValues<IVehicle>(metadata => metadata.ContainsKeyWithValue("Speed", "Fast")); public static IDictionary<object, IVehicle> AllVehicles = App.Container.GetKeyedExportedValues<IVehicle>("Speed"); }
This is what I want to do, but there is no overload of GetExportedValues that supplies a metadata-dependent predicate function. Adding one is easy, though. While we’re at it, we’ll also add the ContainsKeyWithValue which I borrow from The Code Junky article also on MEF container filtering.
public static class IDictionaryExtensions { public static bool ContainsKeyWithValue<KeyType, KeyValue>( this IDictionary<KeyType, ValueType> Dictionary, KeyType Key, ValueType Value) { return (Dictionary.ContainsKey(Key) && Dictionary[Key].Equals(Value)); } } public static class MEFExtensions { public static IEnumerable<T> GetExportedValues<T>(this CompositionContainer Container, Func<IDictionary<string, object>, bool> Predicate) { var result = new List<T>(); foreach (var PartDef in Container.Catalog.Parts) { foreach (var ExportDef in PartDef.ExportDefinitions) { if (ExportDef.ContractName == typeof(T).FullName) { if (Predicate(ExportDef.Metadata)) result.Add((T)PartDef.CreatePart().GetExportedValue(ExportDef)); } } } return result; } }
Now we can test this logic by wiring up MEF and then accessing the two filtered collections of cars, which will each contain a single IVehicle instance.
class App { [Export] public CompositionContainer Container; static void Main(string[] args) { AssemblyCatalog catalog = new AssemblyCatalog(Assembly.GetExecutingAssembly()); Container = new CompositionContainer(catalog); Container.ComposeParts(); var FastCars = TrafficFactory.FastVehicles; var SlowCars = TrafficFactory.SlowVehicles; } }
Viola! We have metadata-based filtering.
You’ll also noticed that I added an Export attribute to the Container itself. By doing this, you can Import the container into any module that gets dynamically loaded. It’s not used in this article, but getting to the container from a module is otherwise impossible without some kind of work-around. (Thanks for pointing out the problem, Damon.)
Let’s take this one step further. Let’s say you want to import many instances of MEF exported values into a Dictionary, using one of the metadata properties as the key. This is how I’d like it to work:
public static IDictionary<object, IVehicle> AllVehicles = App.Container.GetKeyedExportedValues<IVehicle>("Speed");
Again, the current MEF Preview doesn’t support this, but another extension method is all we need. We’ll add two, so that one version gives us all exported values and the other allows us to filter that selection based on other metadata.
public static IDictionary<object, T> GetKeyedExportedValues<T>(this CompositionContainer Container, string MetadataKey, Func<IDictionary<string, object>, bool> Predicate) { var result = new Dictionary<object, T>(); foreach (var PartDef in Container.Catalog.Parts) { foreach (var ExportDef in PartDef.ExportDefinitions) { if (ExportDef.ContractName == typeof(T).FullName) { if (Predicate(ExportDef.Metadata)) result.Add(ExportDef.Metadata[MetadataKey], (T)PartDef.CreatePart().GetExportedValue(ExportDef)); } } } return result; } public static IDictionary<object, T> GetKeyedExportedValues<T>(this CompositionContainer Container, string MetadataKey) { return GetKeyedExportedValues<T>(Container, MetadataKey, metadata => true); }
Add an assignment to TrafficFactory.AllVehicles in the App.Main method and see for yourself that it works.
If you’re using metadata values as Dictionary keys, it’s probably important for you not to mess them up. I recommend using enum values for both metadata property names as well as valid values if it’s possible to enumerate them, and string const values otherwise.
Now go forth and start using MEF!
Posted in Algorithms, Component Based Engineering, Composability, Design Patterns, Visual Studio Extensibility | Tagged: AddIn API, filtering, Managed Extensibility Framework, MEF, System.AddIn | 3 Comments »
Posted by Dan Vanderboom on September 7, 2009
Visual Studio has come a long way since its debut in 2002. With the imminent release of 2010, we’ll see a desperately-needed overhauling of the archaic COM extensibility mechanisms (to support the Managed Package Framework, as well as MEF, the Managed Extensibility Framework) and a redesign of the user interface in WPF that I’ve been pushing for and predicted as inevitable quite some time ago.
For many alpha geeks, the Visual Studio environment has been extended with excellent third-party, productivity-enhancing tools such as CodeRush and Resharper. I personally feel that the Visual Studio IDE team has been slacking in this area, providing only very weak support for refactorings, code navigation, and better Intellisense. While I understand their desire to avoid stepping on partners’ toes, this is one area I think makes sense for them to be deeply invested in. In fact, I think a new charter for a Developer Productivity Team is warranted (or an expansion of their team if it already exists).
It’s unfortunately a minority of .NET developers who know about and use these third-party tools, and the .NET community as a whole would without a doubt be significantly more productive if these tools were installed in the IDE from day one. It would also help to overcome resistance from development departments in larger organizations that are wary of third-party plug-ins, due perhaps to the unstable nature of many of them. Microsoft should consider purchasing one or both of them, or paying a licensing fee to include them in every copy of Visual Studio. Doing so, in my opinion, would make them heroes in the eyes of the overwhelming majority of .NET developers around the world.
It’s not that I mind paying a few hundred dollars for these tools. Far from it! The tools pay for themselves very quickly in time saved. The point is to make them ubiquitous: to make high-productivity coding a standard of .NET development instead of a nice add-on that is only sometimes accepted.
Consider just from the perspective of watching speakers at conferences coding up samples. How many of them don’t use such a tool in their demonstration simply because they don’t want to confuse their audience with an unfamiliar development interface? How many more demonstrations could they be completing in the limited time they have available if they felt more comfortable using these tools in front of the masses? You know you pay good money to attend these conferences. Wouldn’t you like to cover significantly more ground while you’re there? This is only likely to happen when the tool’s delivery vehicle is Visual Studio itself. Damon Payne makes a similar case for the inclusion of the Managed Extensibility Framework in .NET Framework 4.0: build it into the core and people will accept it.
CodeRush and Resharper have both received recent mention in the Hanselminutes podcast (episode 196 with Mark Miller) and in the Deep Fried Bytes podcast (episode 35 with Corey Haines). If you haven’t heard of CodeRush, I recommend watching these videos on their use.
For secondary information on CodeRush, DXCore, and the principles with which they were designed, I recommend these episodes of DotNetRocks:
I don’t mean to be so biased toward CodeRush, but this is the tool I’m personally familiar with, has a broader range of functionality, and it seems to get the majority of press coverage. However, those who do talk about Resharper do speak highly of it, so I recommend you check out both of them to see which one works best for you. But above all: go check them out!
Refactoring code is something we should all be doing constantly to avoid the accumulation of technical debt as software projects and the requirements on which they are based evolve. There are many refactorings in Visual Studio for C#, and many more in third-party tools for several languages, but I’m going to focus here on what I consider to be the most important refactoring of them all: Rename.
Why is Rename so important? Because it’s so commonly used, and it has such far-reaching effects. It is frequently the case that we give poor names to identifiers before we clearly understand their role in the “finished” system, and even more frequent that an item’s role changes as the software evolves. Failure to rename items to accurately reflect their current purpose is a recipe for code rot and greater code maintenance costs, developer confusion, and therefore buggy logic (with its associated support costs).
When I rename an identifier with a refactoring tool, all of the references to that identifier are also updated. There might be hundreds of references. In the days before refactoring tools, one would accomplish this with Find-and-Replace, but this is dangerous. Even with options like “match case” and “match whole word”, it’s easy to rename the wrong identifiers, rename pieces of string literals, and so on; and if you forget to set these options, it’s worse. You can go through each change individually, but that can take a very long time with hundreds of potential updates and is a far cry from a truly intelligent update.
Ultimately, the intelligence of the Rename refactoring provides safety and confidence for making far-reaching changes, encouraging more aggressive refactoring practices on a more regular basis.
I am intensely passionate about any tool or coding practice that encourages refactoring and better code hygiene. One example of such a coding practice is the use of lambda expressions to select identifiers instead of using evil “magical strings”. From my article on dynamically sorting Linq queries, the use of “magic strings” would force me to write something like this to dynamically sort a Linq query:
Customers = Customers.Order("LastName").Order("FirstName", SortDirection.Descending);
The problem here is that “LastName” and “FirstName” are oblivious to the Rename refactoring. Using the refactoring tool might give me a false sense of security in thinking that all of my references to those two fields have been renamed, leading me to The Pit of Despair. Instead, I can define a function and use it like the following:
public static IOrderedEnumerable<T> Order<T>(this IEnumerable<T> Source, Expression<Func<T, object>> Selector, SortDirection SortDirection) { return Order(Source, (Selector.Body as MemberExpression).Member.Name, SortDirection); }
Customers = Customers.Order(c => c.LastName).Order(c => c.FirstName, SortDirection.Descending);
This requires a little understanding of the structure of expressions to implement, but the benefit is huge: I can now use the refactoring tool with much greater confidence that I’m not introducing subtle reference bugs into my code. For such a simple example, the benefit is dubious, but multiply this by hundreds or thousands of magic string references, and the effort involved in refactoring quickly becomes overwhelming.
Coding in this style is most valuable when it’s a solution-wide convention. So long as you have code that strays from this design philosophy, you’ll find yourself grumbling and reaching for the inefficient and inelegant Find-and-Replace tool. The only time it really becomes an issue, then, is when accessing libraries that you have no control over, such as the Linq-to-Entities and the Entity Framework, which makes extensive use of magic strings. In the case of EF, this is mitigated somewhat by your ability to regenerate the code it uses. In other libraries, it may be possible to write extension methods like the Order method shown above.
It’s my earnest hope that library and framework authors such as the .NET Framework team will seriously consider alternatives to, and an abolition of, “magic strings” and other coding practices that frustrate otherwise-powerful refactoring tools.
A tool is only as valuable as it is practical. The Rename refactoring is more valuable when coding practices don’t frustrate it, as explained above. Another barrier to the practical use of this tool is the prevalence of multiple languages within and across projects in a Visual Studio solution. The definition of a project as a single-language container is dubious when you consider that a C# or VB.NET project may also contain HTML, ASP.NET, XAML, or configuration XML markup. These are all languages with their own parsers and other language services.
So what happens when identifiers are shared across languages and a Rename refactoring is executed? It depends on the languages involved, unfortunately.
When refactoring a C# class in Visual Studio, the XAML’s x:Class value is also updated. What we’re seeing here is cross-language refactoring, but unfortunately it only works in one direction. There is no refactor command to update the x:Class value from the XAML editor, so manually changing it causes my C# class to become sadly out of sync. Furthermore, this seems to be XAML specific. If I refactor the name of an .aspx.cs class, the Inherits attribute of the Page directive in the .aspx file doesn’t update.
How frequent do you think it is that someone would want to change a code-behind file for an ASP.NET page, and yet would not want to change the Inherits attribute? Probably not very common (okay, probably NEVER). This is a matter of having sensible defaults. When you change an identifier name in this way, the development environment does not respond in a sensible way by default, forcing the developer to do extra work and waste time. This is a failure in UI design for the same reason that Intellisense has been such a resounding success: Intellisense anticipates our needs and works with us; the failure to keep identifiers in sync by default is diametrically opposed to this intelligence. This represents a fragmented and inconsistent design for an IDE to possess, thus my hope that it will be addressed in the near future.
The problem should be recognized as systemic, however, and addressed in a generalized way. Making individual improvements in the relationships between pairs of languages has been almost adequate, but I think it would behoove us to take a step back and take a look at the future family of languages supported by the IDE, and the circumstances that will quickly be upon us with Microsoft’s Oslo platform, which enables developers to more easily build tool-supported languages (especially DSLs, Domain Specific Languages).
Even without Oslo, we have seen a proliferation of languages: IronRuby, IronPython, F#, and the list goes on. A refactoring tool that is hard-coded for specific languages will be unable to keep pace with the growing family of .NET and markup languages, and certainly unable to deal with the demands of every DSL that emerges in the next few years. If instead we had a way to identify our code identifiers to the refactoring tool, and indicate how they should be bound to identifiers in other languages in other files, or even other projects or solutions, the tools would be able to make some intelligent decisions without understanding each language ahead of time. Each language’s language service could supply this information. For more information on Microsoft Oslo and its relationship to a world of many languages, see my article on Why Oslo Is Important.
Without this cross-language identifier binding feature, we’ll remain in refactoring hell. I offered a feature suggestion to the Oslo team regarding this multi-master synchronization of a model across languages that was rejected, much to my dismay. I’m not sure if the Oslo team is the right group to address this, or if it’s more appropriate for the Visual Studio IDE team, so I’m not willing to give up on this yet.
The next idea I’d like to propose here is that the Rename refactoring is, in fact, a sensible default behavior. In other words, when I edit an identifier in my code, I more often than not want all of the references to that identifier to change as well. This is based on my experience in invoking the refactoring explicitly countless times, compared to the relatively few times I want to “break away” that identifier from all the code that references.
Think about it: if you have 150 references to variable Foo, and you change Foo to FooBar, you’re going to have 150 broken references. Are you going to create a new Foo variable to replace them? That workflow doesn’t make any sense. Why not just start editing the identifier and have the references update themselves implicitly? If you want to be aware of the change, it would be trivial for the IDE to indicate the number of references that were updated behind the scenes. Then, if for some reason you really did want to break the references, you could explicitly launch a refactoring tool to “break references”, allowing you to edit that identifier definition separately.
The challenge that comes to mind with this default behavior concerns code that spans across solutions that aren’t loaded into the IDE at the same time. In principle, this could be dealt with by logging the refactoring somewhere accessible to all solutions involved, in a location they can all access and which gets checked into source control. The next time the other solutions are loaded, the log is loaded and the identifiers are renamed as specified.
If you’ve done much development with Silverlight or WPF, you’ve probably run into the PropertyPath class when using data binding or animation. PropertyPath objects represent a traversal path to a property such as “Company.CompanyName.Text”. The travesty is that they’re always “magic strings”.
My argument is that the property path is such an important construct that it deserves to be an core part of language syntax instead of just a type in some UI-platform-specific library. I created a data binding library for Windows Forms for which I created my own property path syntax and type, and there are countless non-UI scenarios in which this construct would also be incredibly useful.
The advantage of having a language like C# understand property path syntax is that you avoid a whole class of problems that developers have used “magic strings” to solve. The compiler can then make intelligent decisions about the correctness of paths, and errors can be identified very early in the cycle.
Imagine being able to pass property paths to methods or return then from functions as first-class citizens. Instead of writing this:
Binding NameTextBinding = new Binding("Name") { Source = customer1; }
… we could write something like this, have access to the Rename refactoring, and even get Intellisense support when hitting the dot (.) operator:
Binding NameTextBinding = new Binding(@Customer.Name) { Source = customer1; }
In this code example, I use the fictitious @ operator to inform the compiler that I’m specifying a property path and not trying to reference a static property called Name on the Customer class.
With property paths in the language, we could solve our dynamic Linq sort problem cleanly, without using lambda expressions to hack around the problem:
Customers = Customers.Order(@Customer.LastName).Order(@Customer.FirstName, SortDirection.Descending);
That looks and feels right to me. How about you?
There are many factors of developer productivity, and I’ve established refactoring as one of them. In this article I discussed tooling and coding practices that support or frustrate refactoring. We took a deep look into the most important refactoring we have at our disposal, Rename, and examined how to get the greatest value out of it in terms of personal habits, as well as long-term tooling vision and language innovation. I proposed including property paths in language syntax due to its general usefulness and its ability to solve a whole class of problems that have traditionally been solved using problematic “magic strings”.
It gives me hope to see the growing popularity of Fluent Interfaces and the use of lambda expressions to provide coding conventions that can be verified by the compiler, and a growing community of bloggers (such as here and here) writing about the abolition of “magic strings” in their code. We can only hope that Microsoft program managers, architects, and developers on the Visual Studio and .NET Framework teams are listening.
Posted in Data Binding, Data Structures, Design Patterns, Development Environment, Dynamic Programming, Functional Programming, LINQ, Language Innovation, Oslo, Silverlight, Software Architecture, User Interface Design, Visual Studio, Visual Studio Extensibility, Windows Forms | Leave a Comment »
Posted by Dan Vanderboom on September 5, 2009
I am thrilled to finally be living in Aruba, at least for the month of September. This is an experiment in remote working, and an experiment in living outside the United States. “Why Aruba?” you ask. Why not? Aruba has weather that’s perfect for the beach year round, lies safely outside the hurricane belt, and has one of the highest per capita incomes in the Caribbean, making it a very safe and happy place. In fact, their license plate tag line is “One Happy Island”.
Indeed it is! Everyone here has been extremely friendly. The population is ethnically diverse and many languages can be heard. Residents speak Papiamento, Spanish, English, and Dutch generally, and I often hear German, French, Japanese, and other languages I can’t yet identify. It seems common for people living here to speak six or more languages. Being a lover of languages, I hope to pick up as much as I can while I have the opportunity.
I planned many months ahead of time, but found a paucity of information available online and have had to wing-it for many aspects of the trip, which just makes it more of an adventure. Aruban websites are geared toward mainstream tourism and high-profile resort hotel-casinos (many of which are beautiful), but I was looking for longer-term residency, and a bargain at that. I settled for a cheap room off the beaten path, which was about the same rate for a month as a hotel room would be for a week. As it turned out, I was upgraded for free to a nice two-bedroom condominium due to last-minute rescheduling of my original room. I’m a ten-minute walk from Palm Beach, a two-hour walk from the capital of Oranjestad, and at about 20 miles by 5 miles, Aruba is large enough to keep me busy exploring but small enough to make exploring most areas of it possible within my month here.
Yes, I work on projects for several customers while I’m here. I found a fantastic free-Internet Dutch cafe called Cafe Rembrandt with a wonderful staff. I have plugs to power my laptop, and use Skype or iCall to make calls to customers. Both of these have applications for iPhone. With them, I pay $0.20 – $0.27 per minute for calls. Without them, through AT&T (and through SETAR, who is the cell and wi-fi provider for the island), I’d be paying an outrageous $1.69 per minute. This limits me to making calls from free Internet hotspots, or I could pay SETAR $70 per month for unlimited access to their wireless access that blankets the popular parts of the island.
From a technical communication perspective, it’s all working well so far. Because I’m working on smaller projects and my customers are geographically distributed anyway, I’m not running up against many of the hurdles that would appear on larger projects, so it’s a good way to dip one foot into the water without jumping in all the way on day one. Working side-by-side in person with other members on larger projects is always the highest-bandwidth method of communicating, but remote working scenarios are becoming more and more common and have many benefits. The only real way to identify the challenges these scenarios impose is to put yourself into them again and again, and deal with the issues as they come up, finding solutions to problems, working around limitations, and exploiting the advantages that decentralization provides.
Being an avid running and hiker, I’ve walked about four hours a day since I’ve been here, pushing myself as I usually do. The busses, however, are air-conditioned, cheap (about $1.30 per trip just about anywhere), clean and safe, so I always have an easy way home when I’m completely exhausted. They’ll go anywhere you need them to, so renting a vehicle is unnecessary, but car rentals are reasonable if you need one. If you want to rent one, make sure to go to your local AAA and get an International Driver’s License before coming. Also check AAA and tourist books for coupons, which can be 10-20% off of listed rates.
Phones are available for rent, or you can use your existing phone as long as your carrier allows international roaming (you may have to call them to authorize that feature). AT&T customers need to sign up for their World Traveler plan. I use mine only for Google Maps to navigate and to check for email periodically, as the data plans are outrageously expensive if you go over your limit (over $5 per MB).
I could write many pages more about my few days here already, but instead I’ll conclude with a few of the pictures I’ve taken from my iPhone. If you have your own stories about Aruba, or living and working abroad or remotely in general and the lessons you learned, I’d love to hear about them.
Posted in Aruba, Remote Working | Leave a Comment »
Posted by Dan Vanderboom on August 19, 2009
Building a house is still one of the most common analogies I hear and use for discussing software development with customers. The problem is that the architecture of the house is left out; and unless you’re a developer, it’s hard to understand why a stack of wireframes isn’t the comprehensive description of the system needed to provide accurate cost and schedule estimates.
These wireframes are like the diagrams a first-time home owner might sketch on the back of a napkin. In order to know what must be built, and to determine a realistic sense of scope and cost, those rough ideas need to be developed into something much more substantial by a professional. For our house building scenario, this would involve hiring an architect to transform those ideas into a set of drawings which include such things as plumbing, heat and air conditioning ducts, electrical access panels, drains, the appropriate foundation and structural support elements, and so on. The customer asks for a “nice room with a window looking to the back yard”, but all of these other hidden structural elements must be taken into consideration as well.
Unfortunately, determining the actual cost and size of a large project with any accuracy requires having this detailed design; and worse, doing this detailed design can take weeks or even months. By the time development is underway, the customer will inevitably change many of the requirements anyway. In fact, the very process of evolving such a large and detailed design brings many issues to the surface to discuss, debate, and make decisions about. It’s easy to see how this process could carry on for quite a while, and there are still changes in the market to consider and adapt to, both during and after requirements definition.
The house building analogy is useful, but it is also misused. To be fair, a typical waterfall software project put into house building terms would go like this.
However, this is completely at odds with how homes are normally built. People typically choose a previously-implemented design, and only customize superficial features like countertops, cabinets, floors, and railings. Houses from this plan have been built before, and the labor and materials cost are known from previous experience.
Building software is usually more like constructing something that’s never been built before: the first sky scraper, the Golden Gate Bridge, or the Hoover Dam. The requirements are unique, the pieces have never been assembled in such a way before, and there’s an inherent level of risk in creating something new. When this is the case, the Customer needs the services of an Architect, not just a Builder who stamps out deliverables in a cookie-cutter style.
Waterfall methodologies have been dramatically in decline over the years in favor of so-called Agile methods. There are several problems with a Waterfall approach:
The Agile community emerged largely as a reaction to the disappointing results of Waterfall projects. Customers were sick of schedules and budgets that were consistently and grossly overrun (despite all the up-front design), and wanted to more easily change requirements without being put through the wringer to do so. Developers were tired of spending their valuable time writing detailed design documents that kept changing throughout the project, and the burden to update that documentation as the project goals changed focus or priorities shifted made development a very inefficient and slow process.
Essentially, as is often the case, a trade-off was made. Some stakeholders realized that the predictability they were attempting to achieve by spelling out everything in detail was delusional: they were aiming at a moving target regardless of their efforts to pin things down. Project costs rose precipitously because the scope of the system grew. They needed a process that acknowledged and accepted these dynamic project forces instead of one that denied and suppressed them. They needed a process that was efficient, and they gave up the illusion of certainty to get it.
The cone of uncertainty is one of the most valuable tools for visualizing and understanding uncertainty in development projects. From that article:
Research has found that the accuracy of the software estimate depends on the level of refinement of the software’s definition. The more refined the definition, the more accurate the estimate. The reason the estimate contains variability is that the software project itself contains variability. The only way to reduce the variability in the estimate is to reduce the variability in the project itself.
An important—and difficult—concept is that the Cone of Uncertainty represents the best case accuracy it’s possible to have in software estimates at different points in a project. The Cone represents the error in estimates created by skilled estimators [which is up to 16x error at the beginning of a project]. It’s easily possible to do worse. It isn’t possible to be more accurate; it’s only possible to be more lucky.
Commitments made too early in a project undermine predictability, increase risk, increase project inefficiencies, and impair the ability to manage a project to a successful conclusion.
Meaningful commitments are not possible in the early, wide part of the Cone. Effective organizations delay their commitments until they have done the work to force the Cone to narrow. Meaningful commitments in the early-middle of the project (about 30% of the way into the project) are possible and appropriate.
Or as noted by the MSDN documentation for Composite Client Application Guidance:
Application requirements can change over time. New business opportunities and challenges may present themselves, new technologies may become available, or even ongoing customer feedback during the development cycle may significantly affect the requirements of the application. Therefore, it is important to build the application so that it is flexible and can be easily modified or extended over time.
Agile methods have always dealt with small iterations and early, frequent builds to evolve product functionality, but the Lean Development method especially has an explicit focus on making meaningful commitments at the latest possible responsible moment. From Wikipedia:
As software development is always associated with some uncertainty, better results should be achieved with an options-based approach, delaying decisions as much as possible until they can be made based on facts and not on uncertain assumptions and predictions. The more complex a system is, the more capacity for change should be built into it, thus enabling the delay of important and crucial commitments. The iterative approach promotes this principle – the ability to adapt to changes and correct mistakes, which might be very costly if discovered after the release of the system.
While the methodology pundits debate the relative merits of development processes, Tom DeMarco, author of the fantastic books Peopleware and Controlling Software Projects, challenges us to consider the value of our projects and to re-evaluate elaborate control measures in light of the bigger picture. From his article:
To understand control’s real role, you need to distinguish between two drastically different kinds of projects:
- Project A will eventually cost about a million dollars and produce value of around $1.1 million.
- Project B will eventually cost about a million dollars and produce value of more than $50 million.
What’s immediately apparent is that control is really important for Project A but almost not at all important for Project B. This leads us to the odd conclusion that strict control is something that matters a lot on relatively useless projects and much less on useful projects. It suggests that the more you focus on control, the more likely you’re working on a project that’s striving to deliver something of relatively minor value.
This adds additional credence to the idea of agile development, since the Big Design Up-Front (BDUF) of Waterfall is obsessed with detailed definitions to make accurate schedule promises. If the business model is sound, lots of control isn’t needed. It’s better to navigate with a good compass (the product vision) than an incorrect and constantly changing map.
At the end of the day, customers want to know what they’re going to get. There are tradeshow and conference dates to meet, beta and v1.0 launch targets to hit, release cycles to determine, and so on. Ultimately, some up-front architecture and design is usually required. But instead of trying to pin down every detail, it’s actually best in terms of efficiency to share the vision, provide direction, and define the technical scope only in a loose way. This functional scope definition should reflect the reality of the cone of uncertainty at that point in the development process.
At the beginning of the project, items to include in the project should be broadly defined, having a granularity appropriate for the actual uncertainty. As the project progresses and work is done, the scope becomes better defined, risks are determined benign or neutralized, and the cadence of that specific team working on that customer’s specific product can be measured.
This is successfully done with Lean and Kanban approaches, providing an empirical method for measuring productivity. Planning can then be adjusted to match the regular rhythm of production that develops. This creates a semblance of real predictability. You can’t predict any one thing with absolute certainty, but if you can measure the general rhythm at which work is done, you will very quickly learn to recognize how long different kinds of tasks actually take. Because you’re focusing on measured results rather than predictions, it’s easier to normalize task size and estimate larger functional units.
If you’re interested in learning more about Lean development, Mary and Tom Poppendieck’s book Implementing Lean Software Development is a fantastic background and explanation of the Lean process. They also have a new book coming out this November, exploring the same topics more deeply.
When a good process is followed by hard-working, talented developers, the customer will end up with what they need to satisfy their business goals, often in surprising ways, ways that will be radically different from what they initially asked for.
The customer has their vision, beginning with the end in mind as they do; and they are asked to break it apart, prioritize individual features, and stretch their end-goal image across a long and expensive tunnel that separates them from their goal. They usually want some kind of promise of what they’re going to get at the end, even though they’re going to keep adding and changing features throughout its development.
What can be promised? It would be dishonest to promise customers what they’re asking for, unless they promise not to change their minds as the project progresses, but the only certainty in software development is that requirements will change.
Development isn’t about creating flawless, predictable plans that eliminate business risk. Development is an unpredictable journey to create tremendous value. To achieve great reward, risk is a necessary part of the equation. Instead of coming up with creative ways to hide real project risk, it’s best to have a solid process for detecting and managing that risk.
Posted in Goal Setting, Lean Agile, Software Architecture | Tagged: architecture, lean, methodology | 5 Comments »
Posted by Dan Vanderboom on April 29, 2009
[This article and the sample solution included were written with Silverlight 3 Beta.]
The very first thing I did to experiment with Silverlight 3’s new local messaging feature was to create an application with a listener name of “Everyone”, pop up multiple instances of the application, and try sending a message to all of the instances. I got a nasty HRESULT E_FAIL exception message upon firing up the second instance. I closed the application and restarted, only to find I got the same error message on the first instance as well (until I rebooted).
The problem was that a listener must have a unique name and I was violating that rule. There are no groups, and multicasting to multiple receivers in the same group isn’t supported out of the box. Because I didn’t dispose of the object, that name was never released. This seems like a design flaw; when a Silverlight application instance ends, the Silverlight runtime should be able to detect that and release this name resource.
When I heard about this local message passing ability, my first thought was that it would create a neat opportunity, especially in out-of-browser applications, for multiple-window applications. This would be great for those of us who use multiple monitors, as we could then slide panels around where we wanted them, taking full advantage of our workspace.
My sample application, which you can download here, consists of a TextBox, a Submit button that sends the content of that TextBox to all the other instances, and a TextBlock that displays important events. The first time the application runs, it identifies itself as the master window. All subsequent application runs identify themselves as child windows. Here’s a screenshot of this application running out-of-browser:
To accomplish this, the master window will need to have a well known name. I chose MyApp/Master to identify both the application and the window name. Each of the child windows require a unique name, so I chose the format MyApp/{guid}. Once an instance realizes there’s already a master window, it gives itself a child window GUID name and then registers that name with the master window. When a child instance exits, it unregisters itself with the master instance. And finally, when the master window exits, it informs all of the child windows (so they can shutdown, most likely).
I defined several static members in the App class itself, so they would be visible across pages, and also because I wanted to hook into Application_Exit and needed access from there.
public const string MasterWindowName = "MyApp/Master"; public static string WindowName; public static Guid WindowID; public static List<Guid> ChildWindows;
Hooking into the LocalMessageReceiver’s MessageReceived event, I looked for specific keywords in a protocol I quickly cooked up, and in most cases extracted a parameter by parsing the message string. These commands are NewWindow, CloseWindow, MasterWindowClosed, and UpdateText.
void MessageReceiver_MessageReceived(object sender, MessageReceivedEventArgs e) { if (e.Message.StartsWith("NewWindow:")) { if (App.ChildWindows == null) App.ChildWindows = new List<Guid>(); Guid NewWindowID = new Guid(e.Message.Substring("NewWindow:".Length)); App.ChildWindows.Add(NewWindowID); Log("New window detected, id = " + NewWindowID.ToString()); return; } if (e.Message.StartsWith("CloseWindow:")) { var id = new Guid(e.Message.Substring("CloseWindow:".Length)); if (App.WindowName == App.MasterWindowName) App.ChildWindows.Remove(id); Log("Closing window, id = " + id.ToString()); return; } if (e.Message == "MasterWindowClosed" && App.WindowName != App.MasterWindowName) { Log("Master Window Closed"); return; } if (e.Message.StartsWith("UpdateText")) { var text = e.Message.Substring("UpdateText:".Length); txtName.Text = text; // if this is the master window, then distribute to all child windows if (App.WindowName == "MyApp/Master") UpdateTextMulticast(text); return; } }
As you can see, most of this is simple housekeeping code to track which application instances or windows are currently connected to the master window. The UpdateText command calls the UpdateTextMulticast method, which looks like this:
private void UpdateTextMulticast(string Text) { foreach (var id in App.ChildWindows) { var MessageSender = new LocalMessageSender("MyApp/" + id.ToString()); MessageSender.SendAsync("UpdateText:" + txtName.Text); } }
If the window is a child window, the Submit button sends a message to the master window; the master window, when clicking on Submit, calls the UpdateTextMulticast method.
private void btnSubmit_Click(object sender, RoutedEventArgs e) { if (App.WindowName == "MyApp/Master") { UpdateTextMulticast(txtName.Text); } else { var MessageSender = new LocalMessageSender("MyApp/Master"); MessageSender.SendAsync("UpdateText:" + txtName.Text); } }
Finally, this is how a window alerts other windows that it’s closing (in App.xaml.cs):
private void Application_Exit(object sender, EventArgs e) { if (WindowName != MasterWindowName) { var MessageSender = new LocalMessageSender(MasterWindowName); MessageSender.SendAsync("CloseWindow:" + WindowID); } else if (ChildWindows != null) { foreach (var id in ChildWindows) { var MessageSender = new LocalMessageSender("MyApp/" + id.ToString()); MessageSender.SendAsync("MasterWindowClosed"); } } }
That’s about all there is to it. Admittedly, having the same Silverlight application act as both master and child window might not be the best arrangement, and it certainly adds a little to the complexity of the code, but the sky is the limit as far as how the new local messaging feature of Silverlight 3 could be used.
What I’d really like to see is some kind of WCF customization that could define WCF services and host them specifically for consumption across this local messaging channel. Doing so would eliminate the need for defining and parsing a protocol as I’ve done in this example, as WCF could handle the serialization and service method invocation.
Posted in Design Patterns, Distributed Architecture, Silverlight, User Interface Design | Leave a Comment »
Posted by Dan Vanderboom on April 14, 2009
If you’re interested in Cloud Computing, you should consider signing up for Cloud Slam, a very inexpensive four-day virtual conference. You can attend from the comfort of your home (or local wine or coffee shop), and have access to about 100 hours of sessions for only $52. It goes from April 20-24.
Speakers include such industry leaders as Stephen Herrod, CTO of VMWare, Simon Crosby, CTO of Citrix Systems, Werner Vogels, CTO of Amazon.com, and many more.
I can’t say I’ll see you there, but I’m definitely looking forward to it. It should be a great source of information for what industry leaders are thinking and where cloud computing is headed.
Posted in Cloud Computing, Conferences | Leave a Comment »
Posted by Dan Vanderboom on April 13, 2009
[This article and its solution are based on Silverlight 3 Beta and Blend 3 Beta.]
The more I work with Silverlight, the more impressed I am. Though I do keep running into frustrating situations, I haven’t encountered nearly as many dead ends as I did writing Windows Forms applications. But where I used to run into dead ends, I now find myself lost in a labyrinth of deeply-composed control hierarchies, dichotomized content controls, and numerous interrelated control and data templates.
But ultimately I can find a way to do what I set out to do. That’s huge. If the learning curve is treacherously steep and my solution to a problem is tricky and twisted, I can reassure myself of more fluent UI design in the future due to increased understanding. The difficulty of solving these problems is due to complexity of the UI design itself, the immaturity of Silverlight and its APIs, and my own inexperience working with it.
You can download the finished solution here.
When I set out to customize a list control, I didn’t start with the tools of Silverlight. I sketched out a design that assumed anything would be possible, and decided to figure out later how to implement exactly that (in behavior and layout, not final visuals). The mock-up below is similar to what I came up with, simplified to include only those elements I’m going to illustrate in this article.
The first thing you’ll notice is that the data template renders differently based on the data for that item. I found a Code Project article by Anil Gupta on doing the same kind of thing. This turns out to be the easy part. (The space around and between items isn’t intended to be rendered as such, and was added only to emphasize the separate identities of the item templates.)
I also wanted each item in the list to be expandable to display more information and to host interactive controls like sliders (shown in the example) to manipulate the underlying data. In noticing that this button and behavior, as well as the border, are common elements to each of the item templates, I decided that what I was looking at involved a ContentControl. This new control would contain these common elements and a ContentPresenter which would be filled by the specific item type template (one for airplane, one for truck, one for boat). That way, I could build a whole bunch of new templates for new item types and I wouldn’t have to worry about placing the button correctly or wiring up its behavior each time.
Though the illustration might suggest that the only difference among the templates is background color, I wanted to be able to completely differentiate them. The only thing that would be standard would be a collapsed height of 32 to give a nice consistent vertical layout (and for this example, a standard expanded height of 64). Inside, the controls and their layout could follow any design.
Unspecified at first, one of my presumptions was that the width of each item would fill all of the available space, which is the width of the ListBox minus borders, padding, and the vertical ScrollBar. This would prove to be the most difficult challenge, and I found some discussion in the forums, but ultimately I would find my own way to solve it.
Finally, I wanted to do as much as possible in Blend. XAML is fine for setting complex bindings and wiring up other things, but for drawing of graphics (editing templates), I wanted to leverage Blend as much as possible.
First we need a data model, to know the shape of items that we’re binding to in our ListBox. I used a simple example of a Vehicle base class and three derived types. Elsewhere, I instantiate several of each type of vehicle and add them to the ListBox’s ItemsSource collection.
public abstract class Vehicle { public string Manufacturer { get; set; } public string Model { get; set; } public double Price { get; set; } } public class Truck : Vehicle { public bool HasFourWheelDrive { get; set; } } public class Boat : Vehicle { public double HullWidth { get; set; } } public class Airplane : Vehicle { public int MaxAltitude { get; set; } }
I then created three UserControls, one for each vehicle type, and called them AirplaneTemplate, BoatTemplate, and TruckTemplate. I gave each of them a DesignHeight of 64 to represent their expanded state, let their Width be Auto, and set HorizontalAlignment to Stretch. I set the Height of each of the two Grid rows to 32, to ensure they wouldn’t stretch as the ContentControl hosting this content collapsed.
There’s no way that I know of to write an expression in XAML that will bind to a different data template based on item data. I also know of no way to write code behind a data template. To get around these limitations, I created a data template called VehicleListDataTemplate that contains a single VehicleItemTemplate custom control which I could write code behind. This control is a ContentControl, so it’s capable of drawing its own content as well drawing content passed into it. The content that it supplies itself consists of the common UI elements: the border and the button to toggle the expansion or collapse of the item.
This control is mocked up like so, showing both collapsed and expanded states:
The control’s ContentPresenter, set with its Content property, would occupy the same space, although the button would be placed on top to ensure it was clickable.
This was my first custom Silverlight control (other than UserControls), so several things were new to me. For one, defining a default control template in generic.xaml and writing a separate class file for behavior. This is what the default template looks like:
<Style TargetType="local:VehicleItemTemplate"> <Setter Property="Template"> <Setter.Value> <ControlTemplate TargetType="local:VehicleItemTemplate"> <Grid x:Name="Core" Background="{TemplateBinding Background}" d:DesignHeight="32" Height="{TemplateBinding Height}" d:DesignWidth="312" Width="Auto" VerticalAlignment="Stretch" HorizontalAlignment="Stretch"> <Border VerticalAlignment="Stretch" CornerRadius="5,5,5,5" BorderBrush="{TemplateBinding BorderBrush}" BorderThickness="2" /> <ContentPresenter VerticalAlignment="{TemplateBinding VerticalContentAlignment}" HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}" Content="{TemplateBinding Content}" ContentTemplate="{TemplateBinding ContentTemplate}" Margin="0"/> <Button x:Name="Expander" VerticalAlignment="Top" HorizontalAlignment="Right" Margin="0,4,4,0" Width="28" Height="24" BorderBrush="{TemplateBinding BorderBrush}"/> </Grid> </ControlTemplate> </Setter.Value> </Setter> </Style>
And here it’s referenced by the data template:
<DataTemplate x:Key="VehicleListDataTemplate"> <local:VehicleItemTemplate VerticalAlignment="Top" HorizontalAlignment="Left" Background="#0014145D" Margin="0,0,0,0" BorderBrush="#FF5063A5" d:DesignHeight="32" Height="32" d:DesignWidth="430" VerticalContentAlignment="Stretch" HorizontalContentAlignment="Stretch" /> </DataTemplate>
So far that’s not too bad. We have a data template, which refers to VehicleItemTemplate (a ContentControl) that gives our common appearance and hosts a specific vehicle UserControl depending on the item data in question. I count three layers so far, but unfortunately that isn’t enough.
Let’s take a look at how we set the content:
private void VehicleItemTemplate_Loaded(object sender, RoutedEventArgs e) { var vehicle = DataContext as Vehicle; // vehicle will be null when this is executed in the designer if (vehicle == null) return; if (vehicle is Airplane) Content = new AirplaneTemplate(); else if (vehicle is Truck) Content = new TruckTemplate(); else if (vehicle is Boat) Content = new BoatTemplate(); }
Pretty simple: the DataContext is our item data object, we can inspect the type to figure out which one it is, and create a new vehicle UserControl of the appropriate matching type to set the Content.
To make it expand and collapse, we first need to get a reference to the button in our template, which is based on the parts I defined for the control.
[TemplatePart(Name = "Core", Type = typeof(FrameworkElement))] [TemplatePart(Name = "Expander", Type = typeof(ButtonBase))] public class VehicleItemTemplate : ContentControl
In the template, the Expander part must be some control that inherits from ButtonBase, and which therefore implements a Click event. When the template is applied to the control at runtime, OnApplyTemplate is run, so we hook into that event there:
public override void OnApplyTemplate() { base.OnApplyTemplate(); ToggleButton = GetTemplateChild("Expander") as ButtonBase; ToggleButton.Click += new RoutedEventHandler(btnToggleSize_Click); }
private void btnToggleSize_Click(object sender, RoutedEventArgs e) { Duration duration = new Duration(TimeSpan.FromSeconds(0.2)); Storyboard sb = new Storyboard(); sb.Duration = duration; DoubleAnimation ani1 = new DoubleAnimation(); ani1.Duration = duration; ani1.To = Height == 32 ? 64 : 32; Storyboard.SetTarget(ani1, this); Storyboard.SetTargetProperty(ani1, new PropertyPath("FrameworkElement.Height")); DoubleAnimation ani2 = new DoubleAnimation(); ani2.Duration = duration; ani2.To = Height == 32 ? 64 : 32; Storyboard.SetTarget(ani2, Content as Control); Storyboard.SetTargetProperty(ani2, new PropertyPath("FrameworkElement.Height")); sb.Children.Add(ani1); sb.Children.Add(ani2); sb.Begin(); }
Now we have an animation that will smoothly expand or collapse our item and its content, and because I use the To property, we avoid jumping from one state to another. Instead, if we click to expand and then click to collapse again, it will animate from its current position to the desired position.
The biggest problem I had was in setting the correct width. With all Widths set to Auto, each item in the list will take up only as much space as it needs. They can be shorter or longer than the ListBox’s width, and each item could be rendered a different width (depending on the template).
The first thing I tried was to set the VehicleItemTemplate’s Width to the ActualWidth of the ListBox. I didn’t have enough items in my list to see the vertical ScrollBar appear, but even without it, the borders of my item templates were being clipped by the right side of the ListBox, and I could see a gap of several pixels to the left as well as above and below each item.
With the default rendering of Silverlight being that nothing is drawn (border widths are zero, brushes are null, etc.), I find it odd that the ListBox assumes I want padding where I haven’t specified any. After all, if I wanted this, couldn’t I add a Margin to my data template?
I removed the ListBox border, and finally added a ListBoxItem manually to the ListBox in Blend. Right-clicking on that ListBoxItem, I edited a copy of the control template, shown in the screenshot below:
This turns out to be different from the data template defined earlier. This ListBoxItem template is itself a ContentControl, and its content is my VehicleListTemplate… (which is another ContentControl that hosts the specific vehicle UserControls…). See how confusing this can get? I feel like Alice in Wonderland sometimes, seeing how far the Silverlight hole really goes. I also wonder why there doesn’t appear to be any way to edit this template without manually creating a ListBoxItem, when it clearly matters even when you’re defining a data template.
It’s also in this ListBoxItem template that you can render visual decorators to indicate various visual states: Normal, MouseOver, Pressed, and so on. You might expect to handle that in your data template, but that doesn’t seem to be the case.
Anyway, within that ListBoxItem template was this ContentPresenter.
<ContentPresenter x:Name="contentPresenter" HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}" Margin="{TemplateBinding Padding}" Content="{TemplateBinding Content}" ContentTemplate="{TemplateBinding ContentTemplate}"/>
The third line shows a Margin being bound to the Padding property. I removed this Margin altogether, and the gratuitous extra space around my items disappeared, making me happy.
Once you have this custom ListBoxItem template, you need to do two things:
The ListBox XAML should now look something like this:
<ListBox x:Name="VehicleList" HorizontalAlignment="Stretch" Margin="20,20,20,20" Width="Auto" BorderThickness="2,2,2,2" BorderBrush="#FF99A712" ItemTemplate="{StaticResource VehicleListDataTemplate}" ItemContainerStyle="{StaticResource ListBoxItemStyle}"> <ListBox.Background> <LinearGradientBrush EndPoint="0.5,1" StartPoint="0.5,0"> <GradientStop Color="#FF03021E"/> <GradientStop Color="#FF191651" Offset="1"/> </LinearGradientBrush> </ListBox.Background> </ListBox>
Now we’re at a point where the item container itself isn’t adding any extra space, so if we go without borders or a vertical ScrollBar, everything fits just right… until the vertical ScrollBar appears. This is close, but not good enough. How can we take care of the space taken up by the vertical ScrollBar?
While I was digging through the ListBox template, I noticed that the ScrollViewer control had a property called ViewportWidth, and with some debugging saw that it was not quite as wide as the total ListBox width. If only I had a reference to the ScrollViewer from within my VehicleItemTemplate ContentControl! I looked for a while but found nothing. You can call GetTemplateChild from within a control’s class but not from the outside because it’s a protected method.
I decided to cheat. I created a new ListBox class that exposed the ScrollViewer as a property. I felt it was safe to do so because ScrollViewer is a TemplatePart defined in the ListBox’s parts and states contract.
public class MyListBox : ListBox { public MyListBox() : base() { } public ScrollViewer ScrollViewer { get { return GetTemplateChild("ScrollViewer") as ScrollViewer; } } }
I also needed to be able to reference the MyListBox object from each VehicleItemTemplate, so I created a DependencyProperty to store that:
// store a reference to the MyListBox that contains this item public static readonly DependencyProperty ParentListBoxProperty = DependencyProperty.Register( "ParentListBox", typeof(MyListBox), typeof(VehicleItemTemplate), new PropertyMetadata(null)); public MyListBox ParentListBox { get { return GetValue(ParentListBoxProperty) as MyListBox; } set { SetValue(ParentListBoxProperty, value); } }
Next, I set this new ParentListBox property from within the data template I defined earlier (using Element binding, which is new to Silverlight 3):
<DataTemplate x:Key="VehicleListDataTemplate"> <local:VehicleItemTemplate VerticalAlignment="Top" HorizontalAlignment="Left" Background="#0014145D" Margin="0,0,0,0" BorderBrush="#FF5063A5" d:DesignHeight="32" Height="32" d:DesignWidth="430" VerticalContentAlignment="Stretch" HorizontalContentAlignment="Stretch" ParentListBox="{Binding ElementName=VehicleList, Mode=OneWay}"/> </DataTemplate>
Finally, I replaced the ListBox I was using with MyListBox, and in the VehicleItemTemplate_Loaded method, I added the following data binding in code:
// set up data binding: // ViewportWidth of the ListBox's ScrollViewer tells us how much space we have available //(ListBox.ActualWidth - borders - scrollbar) WidthBinding = new Binding(); WidthBinding.Source = ParentListBox.ScrollViewer; WidthBinding.Path = new PropertyPath("ViewportWidth"); SetBinding(WidthProperty, WidthBinding);
When there are more items than will fit in the ListBox, the vertical ScrollBar appears, and the width of all the item templates shrinks to accomodate it. When the ListBox itself widens or shrinks, it adjusts. This seems to produce the perfect fit for items. If you download the sample source code, you’ll notice I set the page to auto size, so when you resize the browser, the ListBox will grow and shrink along with it, and you can easily test it. Also, if you have the ListBox almost full and you expand one of the items with the expander button, you’ll see it adjust then as well.
Here is the final product:
After all of that, we can finally rest assured that we’ll never see a horizontal ScrollBar in our ListBox.
There are several ListBox templates we didn’t take full advantage of: the ItemsPanel for the layout of items, the various embedded templates for parts such as ScrollBars, and the different states of the ListBoxItem template. However, customization of these templates has been covered fairly well by other articles.
Being somewhat new to Silverlight, I’m curious to see how others would have accomplished the same things. Is there an easier way to do some of this? Are there some Silverlight API calls I could have used to reference the ListBox’s ScrollViewer, for example?
I spent many hours working out these details. I hope I can spare some of you the trouble I encountered. Happy Silverlight developing!
Posted in Custom Controls, Data Binding, Design Patterns, Expression Blend, Silverlight, User Interface Design | 1 Comment »
