Here's a very interesting interview of Jason Fried (of 37signals) by Walt Mossberg. It's from a conference on innovation in business. Jason explains how 37signals' business model helps them avoid the pressures of feature creep and how that makes his product a success. He emphasizes the use of the word "No" in developing software and trying to please everyone is the road to mediocrity. He comes up with a fitting analogy using Italian restaurants, but you'll have to watch the interview to hear it. The interview goes on to examine how feature creep affects the success of open source.

The PhotoshopRoadmap.com website has put together a collection of techniques that can be applied to text in Photoshop. Some nice ones and then some that will make you gag, but it's a good display of effects that can be accomplished in the program.

Link to article

I have been evaluating WPF/E for add-ins to my company's products. One screen we have been thinking about for a while is a lead pipeline that shows lead stages in a graphical way. Our products leverage IE for the presentation layer and it is tough to do a compelling pipeline with just DHTML.

WPF/E brings a lot to the table. First of all it is very easy to incorporate into our screens, I simply insert the control code and link in the aghost.js file. It also enables us to easily separate the markup from the script. The HTML file orchestrates the screen while the script and XAML reside in separate files. I also like the division of labor. As shown in these screenshots I've coded the pipeline screen as a segmented pipe along the top of the screen. As the developer I just created simple XAML objects that represented the different elements of the pipeline, nothing too fancy. I then hook up my script to control click-thrus and mouse-overs (the second screen shows how the mouse-over affects the pipeline). In production I would then had the XAML source over to a designer and they would take my rudimentary design and create something beautiful from it. They'd send me the updated XAML file and I just insert back into the development tree and everything should still work with changes. In this case I was the designer too, but you should start to see how this should make development easier.

Another thing that I experimented with was trying to use the same XAML objects and provide an entirely different look and feel for the screen. The final screen shot shows how that turned out. This pipeline demo is very simple, but it starts to paint a picture of how WPF and WPF/E can be used in software. I can imagine that things are not quite as simple when more complex functionality is needed. When trying to change the pipeline into a vertical funnel, I did have to adjust some of my code to make it work.

I did try to use Microsoft's new Expression Design application to create the XAML I used in this demo. I designed the circular pipeline segments and exported them as WPF/E XAML code. That sort of worked, but It generated everything as complex paths and was hard to modify by hand. By the time I had finished the demo, I ended up starting from scratch with the XAML objects. Still, the tools are great and they look very promising.  

In my previous post I had only been using Expression Blend and wasn't able to figure out how to get it to generate content for WPF/E. It turns out that only Expression Design can export WPF/E compatible content (thanks ADO Guy).

If you download and install Expression Design, you can create vector-based elements to include in your WPF/E-based web pages. Expression Design is very similar to Adobe Illustrator. Once you've completed your design, click on File>Export>XAML. This will prompt you for a filename then it brings up a XAML Export window like the one on the right. If you select the Document Format dropdown you can select the WPF/E format. I've tried a couple simple tests that displayed correctly in WPF/E Pad.

This is a good step and may be all we need, however I was expecting this same type of functionality with all the Expression tools. Is that coming?

I first crossed paths with Windows Presentation Foundation/Everywhere (WPF/E) on Mike Harsh's blog post about the Mix '06 event in March of 2006. I knew about XAML and where Microsoft was going with their presentation layer tools, but our company creates mass-market desktop software that doesn't utilize the .Net Framework yet. This meant any XAML or WPF was off limits for us. That is until MS announced WPF/E.

In Mike Harsh's words "(WPF/E) is a cross-platform, cross-browser web technology that supports a subset of WPF XAML.  WPF/E also has a friction-free install model and the download size we’re targeting is very small.  WPF/E supports programmability through JavaScript for tight browser integration.  The WPF/E package also contains a small, cross platform subset of the CLR and .NET Framework that can run C# or VB.NET code."

So XAML and WPF can now be hosted in Internet Explorer. Since my company's desktop applications host IE for the presentation layer, then our presentation layer can take advantage of XAML and WPF. Unfortunately there was not much to be heard of WPF/E since March, but this month MS released a CTP of WPF/E.

where to get started

Probably the best place to get started is the WPF/E Dev Center on MSDN. Download and install the SDK so you can start trying the examples. The Dev Center has a few that you can look at. Mike harsh has also built a cool little application that let's you test your XAML code, called WPF/E Pad. Once you have the SDK installed you can run the WPF/E Pad and try some of the built in examples. After you get a feel for what can be done try entering some of your own XAML. Try copying and pasting the source from below into the bottom panel of WPF/E Pad and clicking the Load button.

<Canvasxmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"x:Name="_037_bugs_logo"Width="1056"Height="816"><EllipseHeight="200"Width="200"Canvas.Left="30"Canvas.Top="30"Stroke="Black"StrokeThickness="10"Fill="SlateBlue"/><RectangleHeight="100"Width="100"Canvas.Left="5"Canvas.Top="5"Stroke="Black"StrokeThickness="10"Fill="SlateBlue"/><LineX1="280"Y1="10"X2="10"Y2="280"Stroke="black"StrokeThickness="5"/></Canvas>

You should end up with something like the screenshot to the left. The XAML creates an ellipse, a rectange and a line. This is not a very compelling example (it was taken from the MS SDK download) but it gives you something to start with. What's nice about the technology is that it allows you to interact with the XAML code using JavaScript. So you can create a bunch of objects using the XAML markup and embed it in your web page, then use JavaScript to program those objects. For example you can attach events to the XAML objects (similar to DHTML) and handle those events in your JavaScript. WPF/E Pad doesn't support event handling at the moment, so you have to take the next step and create your own web page to test out event handling. Those steps are covered in detail within the WPF/E SDK.

what's next?

What makes all this really interesting is how Microsoft is backing up this technology with their development tools. They've recently released an entire suite of apps to generate, manage and debug XAML. Check out their Expression Suite. I think the development tools will be able to target WPF/E versus WPF at some point. Exciting stuff.

Mission Research is a growing, startup company. We do not have an abundance of resources to be throwing at our products and for that reason we are always looking at ways to provide more value to our customers with fewer resources. I'd say we do very well given our constraints, but we can always do better.

Our products are the result of a series of well defined projects. We start out in an Envisioning stage where we define the concept and requirements of the project. Once the concept and requirements are "approved" the project enters the Planning stage. The Planning stage is where the project is defined and a schedule is created. This has historically been the toughest stage of our product cycles.

One of the areas we have been struggling with is figuring out the best way to get a feature or idea from conception to an appropriate level of definition so it can be turned over to our development team. It always seems to take longer than it should and just doesn't feel right. There is always a question about how detailed the functional specifications need to be. We occasionally fall into the trap of going too deep or getting hung up on details that could wait to be figured out. In some cases we actually get so hung up with implementation and technical details that we lose site of what our customers want. In my experience, this tends to happen when developers are brought into the process too early or are even responsible for the designs themselves. I'm not saying that developers can't design software; I just think that they're too close to the code and their thinking is limited by what they perceive as technical limitations.

So I've been thinking lately about setting up some smaller milestones within the Planning stage to keep us on track and guide the definition process. In my mind, the first pass at defining the functionality should be free from technical limitations. Ideally, lock the product manager and designer in the room with a sample of customers and don't let them out until the customers have written a check for the idea based entirely on the high-level specification the designer has created for them. Now that will probably never happen, but the idea is to come up with something that totally meets the needs of the customer without someone standing over their shoulder telling them that what they designed is not possible. I'm not saying the initial design process is void of any logic, it has to make sense and be consistent across the design, but it shouldn't be constrained by what a "technical" person thinks is doable. Allow your designers to think outside the box. Because locking up your customers is not very feasible, what else can be done to create the same environment?

What if we made one of the first milestones in the Planning stage a presentation to the customer? Or if that isn't possible, your customer advocates-- sales, customer support and customer experience. This milestone would ideally occur before there is interaction with the development team. Now this may not be possible depending on your project, but it would be a good litmus test. If your designers are spending time with development before the Presentation Milestone then it should raise a red flag. In our company, a presentation would include some screenshots, a list of capabilities and examples of how the new features will be used. It should be detailed enough to give the audience a good overview. Each group should be evaluating the design from their areas of expertise. Can the support team support it? Can sales sell it? Does the design make sense and does it address the customer need? The Presentation Milestone is crossed when the design addresses all the holes revealed in the presentation.

Whether or not we actually inject that milestone into our product cycle or not, I think it's what the designers should be thinking in the first pass of designing the software. Another purpose of the milestone is to get the designers thinking across the entire functionality set before diving too deeply into the details of a specific function, going wide before going deep. It's very possible that a feature may be passed on once the full scope of the feature set is defined. Hopefully some of that wasted time can be avoided and the design process can be shortened.

Once that milestone is crossed, the designers are free to meet with development to figure out how to implement the design and how long it will take. Obviously some things won't be feasible for technical reasons, but the point is that the design should represent the ideal solution and that's the best place to start in my opinion.

I've run across a neat little script that makes popping up fullsize images from a thumbnail very simple and elegant. I liked it so much that I've integrated the script into this website framework for any images posted to the blog pages. Here's an example:

Integrating it into your own website is very simple too.

Until the box shadow CSS property is implemented, this is a great way to make cool looking shadows around HTML elements on your site. http://theshapeofdays.com/2005/11/my_contribution.html

This site has 6500 free TrueType (TTF) fonts. These are fonts you can download to your computer and use for free. There are some very nice ones in here and being part of a desktop software dev team, I think some of these may be used to produce more usable software. What fonts do you like?

Exploding Boy has put together a selection of free CSS tab designs that may come in handy as we are creating a library of designs for our GiftWorks hosted websites.