When I was preparing for RIAPalooza, I created and blogged about Creating a Simple Silverlight Countdown Blog badge.

It was great but I wanted to updated it for the next event and realized that recompiling it was not really a user friendly option. The answer is that I updated the widget to have a level of parameterization so that I could easily update it without having to recode everything.

*Update – Source Code

The good news is that there’s a mechanism called InitParams that allows you to pass in initialization parameters on startup. I’m not wild about the mechanism itself as it’s just a key-value pair string and not individual parameters but it works. The alternative is to do something where you write some javascript that will call into the Silverlight object and set parameters. While that works, it wasn’t my first choice because you have to worry about the order of events, exposing objects as scriptable and so on.

<object data="data:application/x-silverlight-2," 
    type="application/x-silverlight-2" width="100%" height="100%">
. . .
  <param name="initParams" 
   value="eventDate=01/13/2010,registrationUrl=www.codemash.com,
   registerText=Check it out!,startImageUrl=logo_codemash_2010.jpg,
   endImageUrl=logo_codemash_2009.jpg" />
. . . 
</object>

Notice that there are multiple parameters here separated by commas. The first one is a date and the second one is a URL and so on.

To access that init parameter in the startup you need to open the App class found in App.xaml.cs and in any method use the Host object’s InitParams list.

string fieldValue = this.Host.InitParams[key];

For a lot of reasons, I wrap that up in a method as follows:

private string GetInitParam(string key)
{
    string fieldValue = "";
    if (this.Host.InitParams.ContainsKey(key))
    {
        fieldValue = this.Host.InitParams[key];
    }
    return fieldValue;
}

This allows me to quickly add a lot of new parameters and write the OnStartup method as follows:

private void OnStartup(object sender, StartupEventArgs e) 
{
    string DateTimeString = GetInitParam("eventDate");
    DateTime eventDate = DateTime.MinValue;
    if (DateTimeString.Length > 0)
    {
        try
        {
            eventDate = DateTime.Parse(DateTimeString);
        }
        catch { }
    }

    string backGroundUrl = GetInitParam("background");
    string startImageUrl = GetInitParam("startImageUrl");
    string endImageUrl = GetInitParam("endImageUrl");
    string registrationUrl = GetInitParam("registrationUrl");
    string registerText = GetInitParam("registerText");

    // Load the main control here
    this.RootVisual = new Page(
        eventDate,
        backGroundUrl,
        startImageUrl,
        endImageUrl, 
        registrationUrl, 
        registerText);
}

Notice that I’m calling a custom constructor on the Page class. That looks as follows:

Timer _timer = null;
public Page()
    : this(DateTime.Now, "", "", "", "", "")
{}
public Page(DateTime eventDate, string backGroundImageUrl, 
    string imageStartUrl, string imageEndUrl, 
    string registrationUrl, string registrationText)
{
    EventDateTime = eventDate;
    // Required to initialize variables
    InitializeComponent();

    if (backGroundImageUrl.Length > 0)
    {
        backGroundImage.Source = new BitmapImage(new Uri(backGroundImageUrl, UriKind.Relative));
    }
    if (imageStartUrl.Length > 0)
    {
        image.Source = new BitmapImage(new Uri(imageStartUrl, UriKind.Relative));
    }
    if (imageEndUrl.Length > 0)
    {
        image1.Source = new BitmapImage(new Uri(imageEndUrl, UriKind.Relative));
    }
    if (registrationUrl.Length > 0)
    {
        linkRegistrationButton.NavigateUri = new Uri("http://" + registrationUrl);
    }
    if (registrationText.Length > 0)
    {
        linkRegistrationButton.Content = registrationText;
    }

    _timer = new Timer(new TimerCallback(Timer_Tick), null, 0, 1000);
    AnimateLogos.AutoReverse = true;
    AnimateLogos.RepeatBehavior = new RepeatBehavior(1000);
    AnimateLogos.Begin();
}

That’s all that was required for making it parameterized so that I can update it quickly.

I’ve come to realize that many web designers don’t understand what “Above the Fold” and how it really should be used. Above the Fold is an old print newspaper layout term for what’s on the top part of the page, the part that is displayed in the window at the newspaper stand. In web design, the term is used for the bits that the user can see without having to scroll. I’ve talked and ranted about this before as It’s point number 23 in 32 ways to keep your blog from sucking…

<update>It was brought to my attention that it’s often not a web designer but rather an Information Architect or a Developer who is updating the layout on the page. Completely agreed and this is yet another reason that you should look for competent web designers for the layout and design of your page.</update>

What’s bringing it up now is that CX Partners recently blogged about The myth of the page fold: evidence from user testing | cxpartners and it concerned me a little. CX Partners does a lot of user testing and one of the things that they have tested for is whether or not the “Fold” mattered to users and out of 800 users, only 3 were unable to find content because they would have to scroll to find it. They are right, users are used to scrolling and are willing to do so if they know that there’s more content below. We just need to give them visual hints that there is more content that they will have to scroll to see. What they are trying to fight is the urge to put all of the content or at least all of the *important* content Above the Fold and design pages so that users do have to scroll. I’m on board with that fight. Cramming all of the content into cramped margins and smashing things together just so that it can be seen without scrolling is horrible design.

Here’s the part that concerns me as an old school print layout guy. There’s a fundamental miss on what the “Above the Fold” content is supposed to be used for in your layout whether it’s print or web design.

How does print layout treat above the fold?

The above the fold content is not meant to be the meat of the content or really even the most important content. It’s meant to be eye catching. It’s the lure for people to pick up the paper or magazine.

When thinking about the fold in a newspaper, think about the old school newspaper dispenser with the top half of the top page displayed in the little window. There is a deliberate attempt to put a catchy photo and headline in that window so people buy the paper. Is that the best thing in the paper, not even close. That’s the picture that’s going to look good on someone’s coffee table when they toss down the newspaper.

Or better, think about the magazine stand and how there are potentially hundreds of magazines there and you need for yours to stand out enough that people will buy it. Think this through – what can they see in the magazine stand? Typically they can see the top edge of the magazine and part of the picture. I was amazed once when I was talking to a freelance sports photographer who told me that he’d net $40k-$60k for one photo if he could land the cover picture on Sports Illustrated. But it makes a ton of sense. This concept of trying to stand out on just a headline and a photo is not lost on the smart people at Sports Illustrated. The right picture could make far more than $40k worth of a difference on the stand.

How does this apply to web design?

Honestly, it’s the same exact concept. The fold or scroll line is the area of the page that people can see without having to scroll down the page. This area needs to catch people’s attention correctly because they may only be on you page for a few seconds. If you look at the statistics on any site that gets a decent amount of traffic and the average page view length is measured in seconds, not minutes.

When people are browsing through and they get a link from another site or from a search engine, what’s the first thing that they see? Imagine that as if they are glancing past your page among the potentially hundreds of others that they are looking past which is really not that much of a stretch because they are looking to see which pages are more likely to fit their needs than others. They may not be paying for your content but they are investing their time.

The problems come in two sizes. First, there are designs that try to shove as much content as they can into that above the fold area because there’s an assumption that if it’s not there, their users won’t see it. Second, there are other designs that completely shun the idea of scrolling and end up with these horrid wizard style pages where the user has to click through to see the next page and the next page and so on. Either of these are poor choices.

Back to the article for a moment - I really liked CX Partners’s “Design tips to encourage scrolling”. What was missing is the “How to hook them and keep them” bit.

Let’s look at Jeff Blankenburg’s blog for a good reference here.

You know exactly what you are going to get on his page. The disk in the middle, which is what most people see first cycles through all of the social networks that he frequents. The tweets across the top express his last several publically blasted thoughts while the little bird that flies around them draws eyeballs to them. The menu shows you that he’s delivering Code and Slides through this blog in addition to other posts. The RSS tag that hangs down and swings a little definitely captures the attention and draws people to subscribe. Finally, the title of the blog and the first blog post start drawing eyes down the page to see the meat of the content. But what real content is above the fold on Jeff’s blog? Honestly, there’s none. All of the real content is below the fold so the user has to scroll for it. Going back to the CX Partners post, that’s fine. Users know how to and are willing to scroll for content if they find the page interesting. The *only* thing that I dislike about his header is that it’s a fairly large chunk that takes 3-5 seconds to load the first time. This is a killer if the user is only on the page for 3 seconds.

Another great example is any Amazon product page. They have the picture of the product, average user rating and price right at the top. The product detail, related products, the actual reviews and all of the rest of the content is below the scroll line. Obviously, it’s successful for them.

Wrapping up…

Above the Fold is widely miss-understood. You need to realize that this critical section of the page is not about shoving as much content as you can the user. It’s about effectively giving the “Elevator” pitch on your site and getting that longer look that will likely involve scrolling down to see the real content.

Guard the above the fold content and keep it to the essential bits that will tell the user what your site is about rather than trying to give them everything in one big drink from the fire hose. Whenever anyone talks to you about moving a certain section of content above the fold, turn the question on them by asking them how that keeps people on the site over all.

Building on the success of the DreamSpark and BizSpark program that we launched about 11 months ago Microsoft is now launching the WebsiteSpark program.

WebsiteSpark is designed for small web consultancies ranging in size from 1 to 10 people. With WebsiteSpark, you get a package of software specifically selected for a web consultancy to serve their customers better.

What does the program provide?

WebSiteSpark provides software licenses that you can use for three years at no cost.  Once enrolled, you can download and immediately use the following software from Microsoft:

• 3 licenses of Visual Studio 2008 Professional Edition
• 1 license of Expression Studio 3 (which includes Expression Blend, Sketchflow, and Web)
• 2 licenses of Expression Web 3
• 4 processor licenses of Windows Web Server 2008 R2
• 4 processor licenses of SQL Server 2008 Web Edition
• DotNetPanel control panel (enabling easy remote/hosted management of your servers)

The Windows Server and SQL Server licenses are for you to do both development and production work. Also, the production licenses can be leveraged in a couple of different ways. You can do 1 production server with 4 processors or 4 servers with 1 processor each. These servers can also be either dedicated hardware or virtualized offerings. If you want, you can throw the licenses on your own server with the “self-hosted” model or you can enroll with one of the hosters that have signed up as a Network Partner. As a Network Partner, they will pass the savings of the licenses on to you and only charge you for the infrastructure work. You can find all of the hosting network partners on the WebsiteSpark page.

But this program is not just about software. As part of the WebsiteSpark, the people that enroll are entered into the Microsoft Partner Program and into Microsoft Pinpoint. This will help result in customer referrals and more. There’s also 2 Microsoft professional support incidents per year and some free online training that will be provided. 

Who’s eligible for BizSpark?

WebSiteSpark is available to independent web developers and small web development companies.  The only two requirements to join the program are:

1. Your company builds web sites and web application on behalf of others.
2. Your company currently has less than 10 employees.

If you qualify and want to get signed up today, there are a couple of different paths.

You can always visit WebsiteSpark and sign up directly. During the enrollment, you can pick a network partner or you can pick one of your friends at Microsoft such as me as your contact to enroll and sign you up.

Or you can send mail to webspark@microsoft.com you can get a referral code quickly.  You can then use that code to enroll in the program on the WebsiteSpark website.  Once enrolled you can immediately download and use the software, as well as begin to participate in the network/partner opportunities.

If you run into any issues at all, email me at josh.holmes@microsoft.com and I’ll help you out.

Some quick Q&A

• What happens after the 3 years?

There is a $100 exit fee when you leave the program whether you leave at the end of 1 year or you leverage all three years. However, there’s no obligation to continue using any/all of the software once you exit the program. If you so wish, you can pay the $100 exit fee and wash your hands of the whole deal. Obviously, the play here is that at the end of the three years you will find our platform and tools valuable enough to purchase.

That said, there are some interesting incentives that are being put in place right now to help you with that decision. WebsiteSpark participants can optionally choose to purchase all of the software in the WebsiteSpark program via a $999/year package. And yes, that includes all of the software involved from the tools to the production licenses.  

Or you can just leverage the production licenses through a stellar $199 a year offer that includes both 1 Windows Web Server processor license and 1 SQL Server Web edition processor license.  You can buy the quantity you need of this package at $199/year each. 

• What’s the role of the Network Partner?

Similar to the BizSpark program, the Network Partners are selected because they are active in supporting the ecosystem that the program is intended for. In the case of hosters it’s obvious. They host the websites that WebsiteSpark participants are building. There are others who work with the community in advisory roles and want to help out as mentors and coaches.

Couple of examples:

Cal Evans is another example of a great network partner as he’s working with PHP shops all over the world and helping them to be successful again as a mentor and as a coach. As a network partner, he is adding one more offering into the portfolio to help his mentees be successful.

Steve Smith from Nimble Pros who wanted to be involved as a network partner because he’s active in working with other consults to help them be successful through support, advice, mentoring and sometimes sub-contracting. He’s proven this by being a Microsoft Regional Director and an MVP for many years. His role as a network partner in the program only furthers that goal of helping the ecosystem.

Ben Henderson from Firefly Logic, Harper Reed from Threadless and John Alexander and Jeff Julian from Geeks With Blogs hold similar positions in the community as influential bloggers, coaches, mentors and advisors to many companies.

Summary

I’m really excited about WebsiteSpark because I remember when I was an independent consultant and then a partner at SRT Solutions getting our first dedicated server. It was a great feeling to have the freedom to do whatever we needed to do with the server from installing different types of software to configuring the redirects the way we wanted.

For more details – read Scott Guthrie's blog post at Announcing the WebsiteSpark Program - ScottGu's Blog

Again, if you want to get involved, feel free to contact me at josh.holmes@microsoft.com. Either I can sign you up directly or get you in touch with the right network partner to help you in your situation.

One of the many things that I love about SxSW is that they let the attendees vote for the sessions that they want to see. They are also very realistic that the attendees are not picking the sessions, but they do count for 30% of the vote. Their whole process is laid out on the main page at http://panelpicker.sxsw.com/. It’s 30% attendee votes, 30% staff and 40% advisory board.

The reason that I’m bringing this is that I’ve submitted some sessions this year for SxSW and I need your votes. Typically I don’t do this blatant of a self promotion and/or plea for help but I’m up against some of the best social marketers in the business. :)

Specifically, I’ve got two that are up for votes right now.

The first one is a joint session with James Ward who is one of the technical evangelists from Adobe. He and I are talking about the best and worst practices that we see at our clients every single day.

Title: Best and Worst Practices Building Rich Internet App

Description:
Seen a good RIA lately? A bad one? Because RIAs provide a similar user experience to desktop applications (with the ease of a web/browser-based deployment), confusion results from potentially conflicting practices depending on whether one approaches the RIA as a desktop or a web application. Let’s stop the madness.

Questions:

1. What is RIA?
2. What technologies are considered RIA technologies?
3. When should you use RIA?
4. When should you not use RIA?
5. What's the learning curve for desktop developers to jump into RIA?
6. What's the learning curve for web developers to jump into RIA?
7. What are the best practices for RIAs?
8. What are the worst practices for RIA?
9. How does one deal with multiple form factors?
10. What's the best architectural guidance for a RIA?

The second session that I submitted is a joint session with Jason Gilmore, resident PHP Guru and consultant. He and I are talking about intelligently scaling your applications through cloud computing and our lessons learned actually doing just that.

Title: You Build It, They Come, Your App Scales

Description:
A startup’s biggest hopes - and fears – are hitting it big, and having to scale to 100,000 users overnight. See how PHP combined with Cloud computing provides the best of both worlds - low entry barriers, low startup costs and the ability to scale rapidly to meet demands.

 

Questions:

1. What is Scale?
2. What's the difference between Scale and Performance?
3. What are the ways to scale an application?
4. How do you determine what scale you need?
5. What is cloud computing?
6. What is Azure?
7. How well does PHP work on Azure?
8. What considerations are needed to run on Azure?
9. How do you geo-locate an application?
10. How hard is it to get started with cloud computing?

I need your help getting the word out and the votes flowing. Please tweet about the sessions and/or this post and drive some awareness of my sessions! :)

Putting the "FUN" back in functional programming (or at least taking the "FU" out of it)

Randall Thomas kicked off the morning with a talk on Functional Programming. I have seen a number of talks on functional programming but was really looking forward to Randall’s take on it as he’s not only smart but he’s really entertaining.

The basis for functional programming was that there were a group of guys that were trying to figure out how to mathematically prove that an application was correct. This had strong basis in lambda calculus. The interesting idea here is that since the program can be mathematically proven, you can do things in a almost any order and it will still work. This means that you can

This is a big deal with systems that deal with concurrency. The reality is that any web application has to deal with concurrency. 3D video games deal with concurrency. Distributed computing, cloud computing and many of the things that we are doing on a daily basis have to deal with concurrency.

FU(Thinking) is when you start thinking functionally and solve a given problem in different way than you would have in the OO world.

Recursion is an example of this. Everyone has had to written and messed up a recursive function. The example that he used was calculating a Fibonacci sequence. In straight Ruby, the demonstration was 10-15 lines of code with a while loop, counters that were incremented and decremented and so on. The functional version of that was 4 lines with no looping,

I loved his quote “Amateurs copy, professionals steal” as he put up a demo that he borrowed from someone.

Honestly, he lost me a little on the deltas between procs and lamdas in Ruby.

He brought up the topic of Monads. When he asked the crowd who understood Monads and Jim Weirich didn’t raise his hand, I knew that we were in trouble. Then Randall admitted that he didn’t fully get Monads either. At that point, I knew that I wouldn’t get it probably ever. But he went on to say that mostly people talk about Monads in context of the obfuscated code contests and the like.

List processing is at the core of the things that we do on a day to day basis. There are three things that we do to lists every day.

• Transform everything
• Extract everything
• Combining (everything or something)

Functional programming is really good at list processing.

“iteration is the life blood of ruby – and now a word from some bad ass functional code.”

#Ruby magic – f(x) style
(1..10).reject{ |x| 0 == x%2 }.map.join(‘,’)

So what does that do? It prints out all of the odd numbers from 1 to 10. Notice that there’s no initialization, no main and so on. This is at the core of why people love Ruby. It’s an extremely expressive language.

I was partially nervous that this talk was going to be a pitch for a “Functional” language such as Haskell, Scala, F# or Clojure. But it wasn’t. It was explaining functional programming and help us bend our head around thinking like a functional programmer but accomplish what we need to do *most* of the time in Ruby.

Modeling Workflow Concepts in Ruby or (almost) Everything I Needed to Know about Workflow I learned from Schoolhouse Rock.

David Bock is a workflow consultant. He’s a great speaker and just a fun guy to hang out with.

State-Based verses Process-Based workflows is one of the core concerns in workflow camps.

State-based workflow – this is the thing that reminded David of Schoolhouse Rock. He was thinking about the example of getting a bill passed (http://www.schoolhouserock.tv/Bill.html). There are a lot of different states that a specific bill can be in at any given time. But how things progress from one state to another is the interesting bits. The states are just the points that you would tell your boss if he asked you how things are going. It’s been “Submitted”, it’s “In progress”, it’s “On order”, it’s “Completed”.

To implement a State based workflow, you can do it easily in Rails. David is also working on a project called “Stone Path”

Process-based workflow flips things on it’s head compared to the state based workflow. Or as David said, Process based workflow says that Schoolhouse Rocks was wrong. The state is not what’s an issue, what matters is who does it and how it’s done. This deals with what things can be done in parallel and more. These are things that state based models don’t deal with. There’s a fair amount more handholding and strictness to a process-based workflow engine as it really deals with the “How” of what you are doing, not just the end results.

There’s a project that deals with it well called Ruote.

If you users are novices, you need to choose process-based workflow. This will give them a lot more handholding and rules that they will have to follow.

If you users are experts, you need to choose the state based work flow. This will give them the freedom to skip around, push the boundaries, take shortcuts and anything it takes to get from one state to the next. This can be a good and a bad thing.

"Workflow” is not a tool, it’s a bunch of domain concepts that you can apply and implement yourself.

Playing Nice With Others

Jeremy Hinegardner did this talk about playing nice with other languages and data stores and the like. He talked about the idea that there are three types of persistence that are out there. None, Snapshot and Lifetime. There are times that we need one verses the other

Then he talked about a number of different tools that accomplish various bits along the path there.

Memcache – This is a memory based object caching scheme that is used heavily in a number of different languages including Ruby, Python and PHP.

Tokyo Cabinet – This is a set of libraries that cover a fair amount of ground. They can fit in either the Zero or Lifetime persistence.

Redis - “Redis is a key-value database. It is similar to memcached but the dataset is not volatile, and values can be strings, exactly like in memcached, but also lists and sets with atomic operations to push/pop elements.” – from the Redis home page.

Beanstalk – This is fast, distributed, in-memory work-queue service.

ZeroMQ – This is a memory based messaging system.

The most interesting part of the presentation to me was when Jeremy started showing how understanding what your persistence needs were and how that helped you make your decisions on which of the frameworks to pull down. For example, if you need Lifetime persistence, you should look at Tokyo Cabinet and so on.

Building Native Mobile Apps in Rhode

The last talk of eRubycon was done by Adam Blum on writing mobile applications. The Rhodes framework is an application framework that all allows you to build applications in HTML and Ruby and deploy that application to iPhone, Windows Mobile, BlackBerry, Android and Symbian.

Their tag line is “The Open Mobile Framework”.

The architecture is that they built a small web server and Ruby implementation for each of the platforms. The framework actually loads up the HTML/CSS from the small web server and runs it in the local device’s browser control. I asked him if they ship a browser control or not and he said that they haven’t had to. Specifically he talked about the fact that Blackberry is actually the hardest to work with. They were surprised by the Windows Mobile browser. In their experience, as a browser is not fantastic compared to Webkit based browsers but as a browser control it’s actually very light and works well.

They have a public beta of RhoHub which is a deployment as a service for mobile.

Leadership 101

Jim Holmes kicked off day two with a talk called Leadership 101. This is an amazing talk. Jim, as humble as he tries to be about it, is an amazing leader.

He has posted his slides at http://is.gd/2avEy.

He started off the talk with a story about World War 1 and a story about trench warfare. I knew but it didn’t really hit home that the phrase “Over the top” started in trench warfare. In trench warfare, the troops dig in and build trenches that they basically live in except for when they are on the assault. The phrase “Over the top” referred to leaving that safety and crossing no man’s land, the area between the two armies where you were in the direct line of fire, and going to attack the enemy. This was not a safe thing to ask people to do. But the “brass”, was not on the ground in the trenches. They were miles and miles away in relative safety. In 1912 in France, there was a huge miss that was caused by this separation. They missed the fact that it had been raining for weeks and that the trenches had flooded, the river had flooded, the fields were swamps and there was no way to move quickly. It was suicide to go over the top. But they didn’t know that so they kept sending people over the top and ended up loosing 500,000 men.

The next thing that he talked about is that we, as technologists, need to grow. We are passionate about what we do and take pride in the technology that we implement. But we need to understand business value and how that relates to what we are doing. When we talk to the business owners, we need to express ourselves in terms that they understand. “The business does care, they just speak a different language than we do”.

The next step is to mentor. Take on mentors. Mentor others. But as you are entering these mentoring relationships, you have to be an active participant in the relationship. As one of his early mentors said “You are not a teacup and I am not a teapot and I can’t just poor information into you. You have to be an active participant in this relationship”. Mentoring is a two way street.

Another thing that he talked about is the idea of smart mistakes verses dumb mistakes. If you make a smart mistake, there shouldn’t be any negative consequences for smart mistakes. These are ones where you do the due diligence and make a decision after some thought and it turns out to be the wrong decision. That’s fine. The dumb mistakes are the ones where you make rash decisions without understanding or thinking about the consequences of the decision. These should have consequences.

In order to be a great leader, you have to have the respect of your team, peers, clients and more. But how do you get that respect? “You don’t get respect unless you give respect. You can’t demand respect back. You earn that respect”.

“It’s not just enough for you to be successful. Those around you, below you and behind you have to be successful too. Leading from the rear has never been successful.”

Jim did an amazing talk and really opened my eyes in a number of ways.

Your Rails are Rusty

Adam McCrea from EdgeCase did a talk next about doing Rails development and productivity. He started off the session talking about a project recently where they got started and it took them several iterations to get to a productive state.

The basic problem that he started off is that when he started Rails development, he accepted all of the defaults and was very successful. But over time he kept changing this default or that default and trying new plug ins. Each time he tried a new plugin, he added possible complexity and startup time. He advocates “minimizing decisions - automating as much as possible”. This is the core thesis of the talk. I whole heartedly agree.

“If you’re learning too many new things at once on a project, something has to go if you hope for success” – Joe Fiorini on  Twitter

Adam laid out a number of really good guidelines in his talk.

“Your needs may be more complicated than this, but don’t assume that they are”.

“If you don’t understand the source” of a given plugin, then you should run away. This is a great tip. You can blackbox Rails to a degree but it’s really hard to do that with a given plugin.

One of the things that I really liked that he talks about is that you should pick a default UI for all of your projects that you don’t have a designer to work with on.

Be Careful, Your Java is Showing

Joe O’Brien did a great talk next on developing Ruby as Ruby, not as Java, C#, C++ or whatever language you did last in Ruby syntax. There are some core changes in the mindset that you have to put yourself in to be truly successful.

Unfortunately, I was panicking over my upcoming talk a little so didn’t get to listen to him in great detail.

If someone wants to email me or put a summation in the comments section, I’d happily put it inline here and give them credit.

Enterprise Java

Charles Nutter was the talk right before me. As I was still building some of the demos and getting ready for my talk, I was not able to really get a lot of notes down.

JRuby is in version 1.3. They are rolling along pretty quickly. They are fully 1.8.6 compliant and are most of the way to 1.9. One interesting thing that he pointed out is that you can have 1.8.6 and 1.9 in a single binary.

He showed GlassFish running on JRuby.

He showed running JRuby on the Google Android device. This got a few good oohs and ahhs.

I really wish that I had been in a better spot with my talk to take more notes. Again, if you’ve got a good summation, please help me get that up here.

*Update* – my plea for a summary were answered by Gayle Craig, aha @gayleforce.

"Charles observed that when Ruby first gained it's popularity, many Ruby developers were coming over from the Java world.  And now, some of those folks are going back to Java because their companies are not moving away from the Java platform, and because of the maturity and availability of tools that may not have been written yet in Ruby but are already available in Java.  If the rubyists embrace this, and work to find ways to build bridges between Ruby and Java, then that will continue to entice more Java developers over to Ruby instead of abandoning Ruby.  And that's good for the Ruby community.  And that's what JRuby is working to do.  Charles demonstrated some things in JRuby like ruby2java (a Ruby to Java compiler), become_java, and Jibernate (Hibernate through JRuby.) Charles highly encouraged developers in the room to contribute to JRuby, as there's only a few of them working on JRuby and there's plenty to do…"

Thanks Gayle!

IronRuby

I did the next talk on IronRuby. Largely, I did Jimmy Schementi’s talk from Oscon with my own twist. He posted his speaking notes at jimmy.thinking IronRuby at OSCON 2009 Mono, Moonlight, and scripting open source apps.

The short version of my take on the state of IronRuby is that it’s real this year. Last year and the year before, I talked about IronRuby but I really couldn’t show anything that I would actually consider putting it into production. This year, between the Gestalt stuff, the Witty app with the Repl/IronRuby scripting attached and many many more demos, I had some really awesome and powerful things to show people. I think I turned some heads.

It didn’t hurt that Leon Gersing, who wrote all of the labs and docs for Gestalt, was sitting in the back of the room. 

Why "Enterprise Tools" Are Bad for the Enterprise

Glenn Vanderburg did a talk the next time about the enterprise and how development goes there.

The first thing that Glenn did is rehash his first eRubycon talk on Ruby in the Enterprise. The quick summation goes as follows - “Here are tools that will let you build software quickly, cheaply, with below-average developers”….“Enterprise problems are not nearly as much technology problems as much as they are people problems.”…“You have to write Enterprise software with the expectation that it might still be in production in 30 years. I really liked that talk. These are drums that I’ve been beating, although not as eloquently as Glenn does, for quite some time.

Glenn then talked about a the state of the industry in the form of a case study with Verizon Business. The reality is that there are a number of enterprises that are starting to look at agile development and figure out how it will work for them. There are a couple of ways to go about that. There’s the whole sale change over, which have largely failed for a number of different reasons. The second way is to run a small pilot effort that tries a few small projects to prove things out. These largely succeed but there’s no real follow up.

The reality is that the overall organization might need to change in order set itself up for success. To demonstrate the point, Glenn talked about how accounting was done in manufacturing organizations of old verses today. At one point in time, inventory was considered an asset. While this makes sense on it’s face, it actually created a number of counter incentives for productivity and sales as factories started hording inventory and materials. This pushed a change in the industry to start looking at inventory as a liability. This pushes things like lean manufacturing and just in time ordering of inventory.

So, what we need to do is to start looking for those type of hidden counter incentives in the enterprise. These are actually not that hard to find, we just need to start identifying them and figure out how to articulate these incentives in the correct language for the business.

“Individuals and interactions over process and tools”

Context-Switching is one place where people loose a lot of time. This is not talking about multi-tasking, this is talking about having to change tasks quite often and have the change the mental model to work on.

The next topic was “One job at a time”. The idea here is that there are a lot of tools in Ruby that do one and only one thing. Cucumber is an example. It allows you to write a specific type of test but you can’t really get distracted and do other things while writing in Cucumber because it really only does that one thing.

The next topic was “Crazy as I wanna be”. The idea here is that enterprise tools try to sell you on the concept that with that tool you can do anything. And typically don’t have to write any code in the meantime. The reality is that the tools cannot replace smart people doing smart people. Ruby allows you to do whatever crazy things you want to do without having that crazy be the main stream. This is common for agile tools.

Glenn then started talking about the idea that you shouldn’t buy tools that have “Impenetrable Skin”. These are the tools that typically have lots of configuration options but if you have a need outside of the imagination of the original tools writers, you are stuck. Glenn prefers “Onionskin APIs”. These are the tools and APIs that you don’t have to crack up most of the time but you can if you have to. Rails and ActiveRecord are good examples of this.

Many enterprise tools are often large enough that they are they have their own ecosystem. What that means is they have their own group of people who’s sole job is managing and maintaining the tool. There are lots of examples of this such as databases, service busses and the like. The example that Glenn talked about quite a bit was ClearCase. The issue is that the tool is sold to the people that don’t use it all that much. These tools are sold to managers and project leads who use the tool an hour a week at best. It’s not sold to the developers who are going to use the tool 20 times a day.

The interesting issue is that as these tools start to gather their own ecosystem, the counter incentives start to mount. The use of the tool justifies the ecosystem which promotes the use of the tool regardless of whether or not it’s the right thing because it’s job security for them.

So many enterprises start by treating the symptoms verses actually fixing the problem. One of the treating the symptoms results is rules engines. Rules engines are not inherently the problem. The issue comes in when the rules engine is there because the engineering and development teams are unresponsive. The rules are really code but they are not treated as such. The result is that the people are making changes that are not tested and put through the correct rigor. This will eventually break and we’re back to the beginning.

The next set of symptoms that enterprises take on are really people problems. For example, why are there reuse repositories? Nobody uses them, ever. The reality is that reuse is far more of a people problem than it is a far more than it’s a technology problem. Requirements traceability programs are another great treatment of a symptom. The reality is that these problems are set up to assign blame. Many of the agile tools, such as Cucumber, leveraging index cards or Kanban boards get the benefits of the requirements traceability programs without the overhead and negatives.

The last topic is “Too much control”. The control that the business is really trying to force down is far less about moving forward than it is to keep people from making big mistakes. Too much control, however, stifles innovations and keeps people from making leaps of faith and trying new things.

To get the benefits that people are looking for with the control without the negatives, you need to ratchet up the communications and visibility rather than tightening down thing. Most of the tools in the agile and Ruby space fit this bill really well.

Panel discussion

Joe closed out the day by putting together a panel discussion with a number of people that have had success in the enterprise with Ruby.

Randal Thomas kicked off the panel with a story about a project where he taught a number of VB developers Ruby and was able to kick out and an application that was originally speced for 6 months in about a month. But the business freaked out and shut the project down. They went back and redid the project in “approved” technologies in about 6 months. David Bock followed with a similar story.

The topic quickly shifted to the idea that we really need to understand the business side and how to introduce ideas in such a way that you are not putting them on the defensive. David Bock and Glenn Vanderburg both recommended a book called Fearless Change: Patterns for Introducing New Ideas by Linda Rising.

One of the ideas is that they pitched is that you should start looking for allies. There will be a DBA somewhere that wants to run PostGreSQL and so on. Start quietly gathering that army and mount a campaign.

This is my third year at eRubycon. I’m thrilled to be involved and speaking again this year. I’m shocked every year when Joe picks me as a speaker. I’m just honored to be considered worthy of speaking on a docket with Jim Weirich, Glenn Vanderburg, Leon Gersing, Charles Nutter, Randall Thomas, Neal Ford and all of the rest of the amazing speakers that are here. It’s definitely one of my can’t miss conferences every year.

Joe O’Brien does a great job putting this conference on year after year. The logistics are smooth, the talks are great and the vision for the conference is crystal clear.

SOLID Ruby

Jim Weirich started off the day with a talk called “SOLID Ruby”. The whole talk is already up on github at http://github.com/jimweirich/presentation_solid_ruby. Jim is not only very informative but fun to listen to. I really like his delivery and sense of humor.

The first question that he asked is “How do you recognize a good design?” One of the things that Jim points out is that most people can recognize a bad design but we can’t describe what makes a good design. This is actually quite profound. How can we ensure a good design if we can’t describe what makes one? To demonstrate his point, he talked about the 1666 London fire and the subsequent plans to rebuild the city. He talked about 4 to 6 very distinct designs that were all presented to the king at the time. They actually didn’t build any of designs but rather did the first ever agile project with an incremental build and no huge design up front.

SOLID
S – Single Responsibility Principle (SRP)
O – Open Closed Principle (OCP)
L – Liskov Substitution Principle (LSP)
I – Interface Segregation Principle (ISP)
D – Dependency Inversion Principle (DIP)

SRP – Each class should have one and only one responsibility. You should be able to describe what your class does in a single sentence without using the words “and” or “or”.

OCP – You should be able to change the behavior of a class without having to modify it. This is the basis of inheritance. In Ruby, you can just open a class and “Fix it” right?

DIP – Jim took this one out of order because it made ore sense when trying to explain things. Depend on abstractions, not on concretions. In static language such as Java, C#, C++ it meas that you develop to interfaces. In Ruby, you don’t have to do that as there are no hard references to classes so you can swap out classes at will. If you want to swap out the class, you just have to have all of the methods that the code that leverages that class call. Jim calls this coding to a protocol verses coding to a spec or interface.

LSP – the question answered here is how do you know if you can swap out two classes? The reality is that it’s more than just are the methods require present. It’s what are the promises back as well. For example, if you have a square root function but you require a certain level of precision. From the LISP community, Jim pulls the phrase “Require No More, Promise No Less”. If you are well covered on testing, this will be automatic.

ISP – Make fine grained interfaces that are client specific.

To finish up, Jim opened things up for discussion but in traditional Jim fashion he did things a little different. He brought the questions for the discussion.

First question - “ActiveRecord objects implement a domain concept and a persistence concept. Does that break the SRP?”

Next question - “How do you verify that your client software only uses the (narrow) protocol you expect"?”

Next question - “Some SOLID principles are an awkward fit for Ruby as they were built for static languages. Are there design principles from dynamic languages that are awkward fits for static languages?”

One of the key points that Jim implicitly made is that Ruby the language auto-implements many of the SOLID principles and the the culture pushes the rest of them in great ways.

Testing the Enterprise

I was really sorry but I had to miss this talk. I’m planning on getting a summary from the speakers later tonight and posting some notes later. They posted their slides at http://fallenrogue.s3.amazonaws.com/Testing%20the%20Enterprise.pdf.

In short, Leon Gersing and Charley Baker have been working at the Gap on a large project. A big reason for the success of the project and the team is the rigor around testing.

I asked Leon to email me a short write-up and this is what he sent me:

+++++++++++++++++++++++++++++++++++++++++++++++++
“Testing the Enterprise” is about how we brought Ruby testing into Gap Inc Direct. GID has campuses in Columbus, San Francisco and offshore. In addition to the challenges in a distributed environment, training QA resources and developers new to Ruby, Watir, other libraries; we'll be talking about incremental adoption of Ruby in the Enterprise, and how it enables us to move from a Waterfall SDLC into an Agile model.
We'll be going over lessons learned, pitfalls and successes. The points of view will be from Leon Gersing, who has been responsible for the adoption of Ruby at our San Francisco campus over the past 4 years, and Leon Gersing from EdgeCase, who's working with our Columbus distribution IT organization as they adopt Agile practices and using Cucumber have bridged the gap between developers, QA and product teams.
+++++++++++++++++++++++++++++++++++++++++++++++++

Rails in the Large: How Agility Allows Us to Build the World's Biggest Rails App

Neil Ford came in next and talked about the largest Rails applications known to man.

The application itself is a car wholesaler web site called http://ove.com. He started out talking about how the project came about in the first place. They had a huge complicated web site built in Java. They were looking to do a ground up rewrite in either .NET or Rails.

Neil asked them “There are 300 Java developers downstairs, why don’t you want to rewrite it in Java?” The answer was “Frankly, we don’t want them to touch it.”.

Neil convinced them to go with Rails.

They started out in January of 2007 and built the team at 1 new pair of developers to the project every two weeks. At this point they have 11 pairs of developers, 8 business analysts, an iteration manager, 6 quality assurance, a project manager and a client principle.

One of the key points that Neil made here is that “technology isn’t as important as responsiveness to business needs”. There are a lot of people in the technology world that don’t get that. The reality is that most customers don’t care about what the underlying technologies are, they only care that their business requirements are met.

One of the things that Neil pointed out very strongly, and actually spent a lot of time talking about, is the importance of the testing and specifically the way that they did them. One of the interesting stats that he threw out is that they have 3.2 lines of test code for every line of production code. There’s currently close to 100k lines of test code.

Obviously, this is a lot of code so they have had to pull together a number of other resources and tools to put together to actually run all of the projects. One of them that struck my fancy is DeepTest. It can do distributed testing of your Ruby code. Another one is Selenium grid. This does distributed running of Selenium tests.

One of the side effects of all of this distributed testing is that they have no setup and tear down methods in the tests. Rather all of the tests are completely standalone.

There were a number of social engineering things that they did that were very successful. They have a theme song for broken builds and theme songs for each person that plays on a successful check ins.

Agile, Rails and the Cloud: Why companies can't afford to ignore the efficiencies of modern development approaches

Ian McFarland finished off the day with a talk about why modern development approaches matter to business. This is a very important thing to talk about and think about for businesses. The reality is that not nearly enough people spend time considering.

He started talking about Agile development and walked through many of the core tenants. He put forth fairly compelling arguments that you really do need to follow the tenants of Agile. For example, having the customers setting the priorities on the things that you are building matters because it helps you produce business value faster. He spent quite a bit of time arguing that you really do need to do paired programming. Everyone learns more faster, gets distracted less and the team knowledge goes up dramatically.

After that, he switched to talking about Rails. He’s got data that switching from Java to Rails proved out to have have 2-4x productivity gain for the developers.

Then he talked about the Cloud. To steal words from Brian Prince to help paraphrase Ian’s thoughts here - “Don’t be a plumber!”. Unless it’s critical to your business to run your own infrastructure, you should outsource the infrastructure. Actually, he made a strong argument that you should outsource a number of things. As I’ve said for a long time, if it doesn’t add to your companies stock price, why are you building it? There are times that you have to run your own infrastructure such as regulatory issues or business needs that make it more advantageous to have it internal.

At the end, he made a very contentious statement that Rails is not ready for the Enterprise. There are a number of reasons for this and mostly it comes to the fact that Enterprise is actually not ready for Ruby. The actual barriers are being solved. For example, companies such as Engine Yard are solving cloud issues and the like.

 

Now for dinner – more tomorrow!

 

I recently did a keynote at the Central Ohio Day of .NET and a session at Kalamazoo X called “The Lost Art of Simplicity. I have to say that I’ve not been as excited about a specific talk in quite a while.

I posted the slides to SlideShare and I’ve signed up for speaker rate for this session. I would love some feedback.

Slides on SlideShare - http://www.slideshare.net/joshholmes/the-lost-art-of-simplicity

Speaker Rate - http://www.speakerrate.com/talks/773-the-lost-art-of-simplicity 

The Lost Art of Simplicity - Presentation Transcript

1. The Lost Art of Simplicity Josh Holmes joshholmes.com josh.holmes@microsoft.com
   
   
2. sim·plic·i·ty (sm-pls-t) n.
   1. The property, condition, or quality of being simple or uncombined.
   2. Absence of luxury or showiness; plainness.
   3. Absence of affectation or pretense.
   4. a. Lack of sophistication or subtlety; naiveté.
       b. Lack of good sense or intelligence; foolishness.
   5. a. Clarity of expression.
       b. Austerity in embellishment.
   

   Let’s start off by talking about what simplicity is. The official dictionary definition has 5 parts. We are going to focus in on the first definition. Simplicity is the property, condition or quality of being simple or uncombined. This is a beautiful statement that is unfortunately missing in much of our current application development.

   When we talk about something being simple, often people just right to the fourth definition assuming that it’s lacking sophistication or good sense and intelligence. That it’s foolish. As technologists, our tendency when we see something that’s simple is to say “Oh, I could write it in a weekend”. There’s a fair amount of NIH (Not Invented Here) tendencies that are just part of our culture. This is a dangerous concept.

   The last definition is the one that I really like. To have a something that has “Clarity of Expression” is awesome. Put that with the first definition and we really have something. I’m striving to solve problems in ways that are “Simple and uncombined” with “Clarity of Expression”.

   http://hikingartist.com/Peopletypes_g54-King_type_p124.html

   http://www.thefreedictionary.com/simplicity

3. Simplicity is an acquired taste. Mankind, left free, instinctively complicates life - Katherine F. Gerould
   
   

   One of the great things about the human race is that we are a race of problem solvers. And we take great pride in our solutions. The issue is that the solutions that we are most proud of are the ones that only we can understand.

   The best ideas, however, are the ideas that are immediately obvious once someone shows it to you. It’s that head smack “Duh” moment that accompanies those great ideas that I really like.

   http://hikingartist.com/animals_g58-evolution_p60.html

4. I adore simple pleasures. They are the last refuge of the complex. - Oscar Wilde
   

   Let’s use the example of this guy dreaming about having that apple for lunch… It’s a fairly simple problem on it’s face. We, as IT folks, get the IT equivalent of this issue day in a day out.

   http://www.flickr.com/photos/hikingartist/3010374978/

5. Our life is frittered away by detail. Simplicity, simplicity, simplicity! - Henry David Thoreau
   
   

   Can I get report of sales by geography? How about splitting that by demographics such as age or gender? What’s the effect of our current marketing efforts on sales of our latest line and how does that differ by geography or demographic? Could I enter a contact I met at the picnic into our CRM? Could that be blue?

   http://hikingartist.com/Cartoon_illustration_g29-Still_want_that_apple__p262.html

6. Any intelligent fool can make things bigger, more complex, and more violent. It takes a touch of genius -- and a lot of courage -- to move in the opposite direction. - Albert Einstein
   

   Our biggest fear is that the user is going to go get a copy of Access or something equally destructive and try to solve the problem themselves. Often they can effectively solve the short term problem and in the process bring down the enterprise…

   And this is a dangerous thing because as they open up the simple tools such as access and solve just their problem, they are potentially causing other issues like data redundancy throughout the company or duplicating efforts with another group. Often these solutions are even done with ignorance to larger concerns such as privacy laws.

   Even so, they are solving their problem in the short term and that was their goal.

   http://www.flickr.com/photos/hikingartist/3010374978/

7. Most of the fundamental ideas of science are essentially simple, and may, as a rule, be expressed in a language comprehensible to everyone. - Albert Einstein
   

   To head that off, we just, we start throwing our favorite technologies and designs at the problem to solve it in the most “elegant” way. This quickly results in over engineering the task at hand.

   One immediate and obvious danger is that we take that simple request and roll it into the next version of the application that’s going to be 18-36 months down the road ignoring the fact that it’s a pain that the user is feeling today. What happens when, 18 months down the road, the user that has requested that feature has solved the problem some other way? Or if that user is not even employed by the company anymore?

   http://www.flickr.com/photos/hikingartist/3010375012/sizes/o/

8. It takes a long time to make something complicated simple, but if you do, it will work w/o problems for a long time. - F. Andy Seidle, http://faseidl.com/ 
   
   

   And the solution that results is not only over engineered but it’s reminiscent of a certain coyote with all of the possible ways that it can fail. The reality is that the more complex a problem is, the more ways that it can fail.

   As a solution ramps up in complexity and “cleverness” it quickly becomes more fragile because there are more moving parts and more possible points of failure. Just because something is using the latest or coolest technology, doesn’t mean that it’s the best idea. If that latest or cool technology reduce complexity in some way, such as reducing the number of tools, streamlining process or raising the bar on the usability then there is a good argument to leverage it.

   http://www.flickr.com/photos/hikingartist/3009540065/

9. The Innovator’s Dilemma that disruptive innovations are almost never the result of technological breakthroughs but are instead recombination's of existing and often inexpensive technology in forms the former market leaders don’t pursue. - Clayton Christensen
   

   In all of this, we are missing the obvious. There are known simple solutions to a lot of the requests that we get on a day to day basis.

   The first thing that we have to get over is the NIH complex that we all have. When you get a new request is your first thought, I can build that… Or is your first thought, I bet that’s been built…

   The second thing that we have to recognize is that the simple solution is probably the right one. If the solution that we have come up with is a so complicated that we are amazed with ourselves and proud of it, it’s probably the wrong direction.

   http://hikingartist.com/Cartoon_illustration_g29-Want_an_apple_p261.html

10. Dealing with complexity is an inefficient and unnecessary waste of time, attention and mental energy. There is never any justification for things being complex when they could be simple. - Edward de Bono
    

    We can’t keep down this destructive path of building more and more complex solutions that take eons to develop when the users have needs that we are not addressing in the short term.

    http://hikingartist.com/Cartoon_illustration_g29-Want_an_apple_p258.html  

     

11. I’m Fine
    

    We are living in denial that we are the problem. It’s our insistence that we are the technical gods and know everything that is driving this as a problem in the industry in the first place.

    http://hikingartist.com/Cartoon_illustration_g29-Not_to_be_disturbed_p398.html  

12. We need to be very careful about the lure of complexity. We should not fall into the trap of thinking that if it’s hard to design, it must be good; that if it’s using the latest technology, it must be good; that if all our friends think it’s really cool, it must be good. - Gerry McGovern
    

    We, as the IT world, tend to go rampant with technology with little to no thought to the consequences. Even though we are trying to make people’s lives easier, at best we do no harm. At worst, we cause a lot of pain and anguish for our users.

    The answer that a lot of us, and I’m guilty of this too, turn to is to vet our ideas and our UI designs with our peers. The issue is that our peers are also technologists who are just as geeked as we are about X new technology. This just perpetuates the problem.

    http://hikingartist.com/Peopletypes_g54-The_akward_type_p86.html

    http://www.gerrymcgovern.com/nt/2004/nt_2004_11_22_complexity.htm

13. Things should be made as simple as possible, but not any simpler. - Albert Einstein
    

    Let’s take a short step back and examine how complexity comes to our applications in the first place.

    Often complexity sneaks in under different names. One of my favorite is “Enterprise” which almost automatically means a complexity multiplier of 10. The idea here is that we have to be “Enterprise Quality”. This implies a certain engineering rigor, stability and scalability. One huge issue that I have with this term is that if you look at a mid to large sized enterprise with 10k, 20k or even 50K users you are still looking at a user base that would be considered a rounding error on some of the larger consumer facing applications such as Facebook, Twitter, Wikipedia and the like.

    http://hikingartist.com/animals_g58-Trojan_trap_p106.html

14. The whole point of human-centered design is to tame complexity - Don Norman
    

    Often the complexity is as simple as not understanding our users.

    I was recently in a long envisioning session with a customer about the next version of their client facing applications. We spent a lot of time hashing through their current application and came up with a number of ways that we might be able to save time or give a better experience. But at some point I backed up and asked the question, what are the top three things that your customers do with the application? If we knew that, we could focus on surfacing those to three tasks in the UI to help cut complexity and time out of the user’s day. The reality is that they couldn’t answer that question. There were some guesses and opinions thrown out but nothing definitive that they could throw out. Their homework assignment was to go back and find that out.

    I find this as an issue in a lot of customer engagements. Very few companies actually know how many of their users are using Windows 98 or IE5 but there is an assumption that it’s an issue so a lot of complexity is built into the system in order to accommodate what might very well be a small portion of their audience.

    The other side of this issue is that there’s what the users say that they want and what they actually need. There are some simple examples. “Could you Web 2.0ify my site?” “I need a X (where X is some buzzword that they just read in some article) technology application” Or any other place where technology enters requirements. This is where we need to redirect the user’s requirements by asking them about their goals and aspirations and then start figuring out what they need from that. “Oh, you want to cut down on the amount of text that your users have to type while increasing the accuracy of their reporting? How about we replace that block of text by allowing them to select a picture of what they are looking for? Yeah, we can do that without requiring them to wait on the page to reload.”

    http://www.flickr.com/photos/hikingartist/3208741909/sizes/o/

15. I apologize for the length of this letter, but I didn't have time to make it shorter. - Mark Twain
    

    An unfortunately common problem that I see in the industry is that given group of developers knows one or two technologies and approach every problem with that technology as the solution. The reality is that that there are tremendous number of technologies at their disposal from web applications to desktop applications to mobile applications to hybrid solutions of all of those. You need to approach each problem with an open mind as to what is the best solution for that problem. Sometimes you’ll find that the solution is not actually a technical solution at all.

    The real solution here is to take the time to explore all of the possible solutions, technology based or not.

    http://hikingartist.com/meetings_g55-hammer_management_p129.html

16. Ok. now what?
    

    Where are we now and what can we, as mere cogs in the wheels, do to tackle this problem?

    http://hikingartist.com/Cartoon_illustration_g29-Short_term_solution_p408.html  

17. \"Think simple\" as my old master used to say - meaning reduce the whole of its parts into the simplest terms, getting back to first principles. - Frank Lloyd Wright
    

    There’s, unfortunately, not a magic solution to the issue of complexity. Simple is hard.

    Often you have to come up with several complex solutions that you can boil down to the simple solution. Often, in an effort to find the right solution, I will solve or at least map out solutions to a given problem in several different ways with a number of technologies ranging from desktop to web to mobile to non-technology solutions. Kind of like going to a shoe store and trying on a ton of different styles and sizes of shoes, you can get a lot of interesting ideas from checking out all of the different solutions. You might be surprised by the solutions that make the most sense at the end of the day.

    http://hikingartist.com/Cartoon_illustration_g29-Wizard_type_3_p111.html  

18. Simplicity is not the goal. It is the by-product of a good idea and modest expectations. - Paul Rand
    

    All of that said though and as much as I’m talking about Simplicity in this talk, the reality is that Paul Rand has it right. “Simplicity is not the goal. It is the by-product of a good idea and modest expectations”.

    http://hikingartist.com/Motivation_g56-The_just_enough_Type_p116.html

19. Never again will I make the simple into the complex. Something of true value does not become more valuable because it becomes complicated. - Donald Curtis
    

    One of the biggest problems is that we try to, for a large number of reasons, try to boil the ocean with our applications. When we build out our project plan and it’s going to be an 18 month cycle before the users get a new version, they are going to go to battle tooth and nail to get their feature request on the docket because they know that if they are not able to get it in this release, it’s going to be at least 36 months out. All of these features crammed into a release adds not only a lot of complexity but a lot of risk to the endeavor.

    We have to get past the misperception that features equal value. Features do not equal value. Solving people’s problems equals value. The amount of complexity and risk that we add with these massive project plans hurt out ability to solve someone’s problem in a reasonable time frame.

    http://hikingartist.com/animals_g58-Fishing_type_p112.html

    http://en.wikipedia.org/wiki/Willard_Gibbs

20. The ability to simplify means to eliminate the unnecessary so that the necessary may speak. - Hans Hofmann
    

    You need to start small. Even if you know that the end game is far bigger, what’s that first step? What’s the minimal set of features that you need to get started? This is a struggle for a lot of people as we all want to go for the big vision. The natural tendency is to think that more is better but in a lot of cases, more just gets in the way of success.

    This is a core concepts that groups like 37 Signals have held. Their motto is that the first order of business is to get running and start building a customer base. You can worry about scaling later. But if you spend too much time worrying about scaling up front, you’ll never get out there to build the customer base in the first place.

    http://hikingartist.com/meetings_g55-Fools_can_t_you_see_the_bird..._p12.html

21. Making the simple complicated is commonplace; making the complicated simple, awesomely simple, that’s creativity - Charles Mingus
    

    On the other side of the coin, you need to have a clear concept of the future as you are getting started. I often see applications that are built with no concept future requirements and accidentally build in roadblocks to success. There are a lot of simple things that you can do that will future proof your application to some degree. It’s not hard to build in, if you start from the beginning with a tiered and separated architecture so that you can replace bottle necks if they start to pose a problem.

    This is sometimes a hard balance to hit but it’s an important one to tackle.

    There are a lot of straight forward things you can do such as adopting some of the great architectural patterns such as MVC (Model View Controller) or MVP (Model View Presenter) combined with great practices such as Test Driven Development (TDD). TDD is more than just building regression tests. It forces you to design and build your application in a modular fashion that allow you to make changes and modifications to your application quickly and with confidence. MVC and MVP are architectural patterns that work well with TDD and provide for great separation of concerns to further provide the agility that you need to grow and scale your application over time.

    http://hikingartist.com/meetings_g55-Not_quite_ready_p7.html

    http://en.wikipedia.org/wiki/Hans_Hofmann

22. When thought is too weak to be simply expressed, it's clear proof that it should be rejected - Luc De Clapiers
    

    http://hikingartist.com/Peopletypes_g54-The_engineer_p121.html

    http://en.wikipedia.org/wiki/Luc_de_Clapiers,_marquis_de_Vauvenargues

23. The whole is simpler than the sum of its parts. - Willard Gibbs
    

    None of this means that I’m not solving complex problems. It just means that I’m layering simple solution on top of simple solution to solve those complex problems.

    http://hikingartist.com/Free_print_versions_g79-Building_bridges_p747.html

24. The first requirement for an exemplary user experience is to meet the exact needs of the customer, without fuss or bother. Next comes simplicity and elegance that produce products that are a joy to own, a joy to use. True user experience goes far beyond giving customers what they say they want, or providing checklist features. - Nielsen Norman Group
    

    So where to from here?

    As I look into the future, I see a world where we are working hand in hand with our users to solve their real needs rather than reacting to what they say that they want and confusing checklists of features with value. I dream of the day when we are able to respond to the users needs as quickly as we can get them to express those needs to us to the point of being able to forecast and proactively provide exactly the functionality that the user needs, nothing more, when they need and not a moment before they do.

    To do that, we need to forgo our egos, our love of complexity and our die hard grip on our favorite technologies and focus on the user.

    http://hikingartist.com/meetings_g55-The_observer_type_p135.html

25. Go confidently in the direction of your dreams! Live the life you've imagined. As you simplify your life, the laws of the universe will be simpler. - Henry David Thoreau
    

    You call to action is to go to war against complexity. Stand up for simplicity.

    Take the extra time that it is going to take to build the uncombined solution that has clarity of expression. Don’t confuse simple with lack of sophistication.

    Focus on your user and their needs.

     

    As you do this. As you take on this challenge and “as you simplify your life, the laws of the universe will be simpler”.

    http://hikingartist.com/Motivation_g56-The_gatekeeper_type_p48.html

26. All artwork used in this presentation is licensed under Creative Commons by Frits Ahlefeldt, aka hikingartist Support his amazing craft at http://hikingartist.com
    

    Before I finish, I need to say a quick thank you to Fritz Ahlefeldt. He’s a Danish artist with obvious talent. He publishes a large amount of his work under creative commons. If you like this art, you can see much more at http://www.hikingartist.com and support him and his amazing craft.

27. The Lost Art of Simplicity Josh Holmes joshholmes.com josh.holmes@microsoft.com
    

I’m looking forward to evolving this talk as I move towards CodeStock and DevLink. I know that there was a really nice progression in just a week between Central Ohio Day of .NET and Kalamazoo X as my message got a lot crisper and more direct based on a lot of great constructive advice I got from Michael Eaton, Michael Wood, Jim Homes and more.

I had heard about this effort a few weeks back but I’m thrilled that it’s public and I can talk about it now. Karsten Januszewski and some of the other whiz kids on the MIX team have put together a visual designer for jQuery called Glimmer.

Right now, they’ve got a number of design wizards that you can leverage but they’ve built a great plug-in model so that you can write your own for your favorite jQuery UI plug-in.

Check out their video on how to leverage Glimmer and how it all came to be.

I’m really geeked and am looking forward to using this in my next web dev projects…

I’m going to be speaking at RIAPalooza in about two weeks, well more specifically at the time of this writing it’s 10 days, 12 hours, 48 minutes and 45 seconds. :)

I’m going to be tag teaming with Mike Labriola again talking about “10 questions about RIA you haven’t had the courage to ask”. We’ve got a short list of questions but are hoping to get some questions from the crowd as well. If you happen to have any questions, feel free to shoot them to me in the comments section on this post.

Anyways, we were discussing different ways to get the word out about RIAPalooza and someone mentioned that we didn’t have have a blog badge so I decided to create one.

I started by grabbing some art from the RIAPalooza web site. I started out in Expression Blend with a simple Silverlight project. Here are the steps that I took.

1. Resize the Page.xaml user control to 100x200 to fit the blog badge size.
2. Add the wood background that I grabbed from the RIAPalooza web site trimmed down to the blog badge size.
3. Paste in the two other images, one for the logo (referred to as i and one for a a free t-shirt offer.
4. Animate the two images to wiggle, spin, wiggle, wait, wiggle, spin, wiggle, wait, reverse.
   •  
     To do this, I opened a timeline and started by rotating the first image -6 degrees and then a frame later rotating it to 6 degrees and then a frame later back to 0. This gives the images a nice little wiggle and catches the viewer’s eye without being too annoying. Well, I don’t think it’s too annoying but you can tell me…
   • 
     Then I kicked forward 2 seconds and did the wiggle again in preparation of swapping to two images. The wiggle makes a nice little transition before the action starts.
   • 
     At the end of the wiggle, I spun the image on it’s X axis over the span of half a second. That’s accomplished by setting the X Skew to zero.
   • On the same frame that the first logo hits an X Skew of zero, I make the other image visible with it’s X Skew to zero an proceed to transform it’s skew to 1 (normal) over the course of a half second.
   • Then I wiggled the t-shirt offer image in the same manner that I did the first logo.
   • Now, back in the code, I set a few properties and started the animation.

     AnimateLogos.AutoReverse = true;
     AnimateLogos.RepeatBehavior = new RepeatBehavior(1000);
     AnimateLogos.Begin();

5. Now that the logos are moving, I needed a link to the site. Simple enough using a HyperLinkButton.
6. Last thing I needed was to provide some type of count down. At first I just used a couple of labels and set the text.
   • First, I used a timer set to go every second and set the time
     _timer = newTimer(newTimerCallback(Timer_Tick), null, 0, 1000);
   • Next I used the dispatch object to work on the UI thread as follows:

     public void Timer_Tick(object state)
     {
         Dispatcher.BeginInvoke(() =>
           {
               try
               {
                   DateTime launchDate = new DateTime(2009, 5, 8, 8, 0, 0).ToUniversalTime();
                   TimeSpan span = launchDate.Subtract(DateTime.Now.ToUniversalTime());
     
                   txtDays.Text = string.Format("{0} Days", span.Days);
                   ...
               }
               catch
               {
                   //Eat all errors. We'll get another chance in a second... 
               }
           }
         );
     }

There are a couple of things to notice about the code above. First, I just used everything as UniversalTime. I thought about trying to do the whole timezone thing but realized that it didn’t matter for a countdown because as long as everything was in the same timezone the math would be right.

Second, notice that I’m eating all of the errors in the timer. The basic error that I can get from this code is a threading issue and since this is low priority code, I didn’t care about the threading issue. It’s not like there’s a real recovery path other than trying again in a second.

Now that I had the simple countdown and badge done, I decided that I didn’t like the flat labels and wanted a real clock style count down. To accomplish this I started a Silverlight FlipClock project to build a reusable clock face.

Since I was creating a flipping clock with a separate top and bottom, it made sense to create a control to encapsulate those bits in user controls that I could reuse. There were two interesting parts here. First, how to get the text to cut off at the top and second, how to get the text to scale correctly with the number if we resized it.

The first issue was solved by using a brush that cut off to an opacity of zero just under halfway. I did that on both the background and the textbox. The whole gradient is actually made up of three stop points. Two set to be the same color and opacity of 100% and a third that is set to the same color but opacity of zero. This third stop is just a hair further down than the second. The purpose of the second stop is to keep it from fading from top to bottom rather than having the hard like that I desired.

<LinearGradientBrush EndPoint="0.5,1" StartPoint="0.5,0">
    <GradientStop Color="#FFFFFFFF" Offset="0"/>
    <GradientStop Color="#FFFFFFFF" Offset="0.48"/>
    <GradientStop Color="#00FFFFFF" Offset="0.49"/>
</LinearGradientBrush>

The second issue was solved thanks to Laurent Bugnion. He pointed out that although Silverlight doesn’t have a scalable font, there is a VIewbox in the Silverlight Control Toolkit on Codeplex that will scale anything inside itself correctly.

<controls:Viewbox Height="Auto" HorizontalAlignment="Stretch" Margin="0,0,0,0" 
VerticalAlignment="Stretch" Width="Auto" Content="Viewbox" Stretch="Fill">
<Grid x:Name="LayoutRoot" Background="{x:Null}">
. . .
</Grid>
</controls:Viewbox>

I added a simple property to set the value in the textbox.

public int Value
{
    get
    {
        return int.Parse(txtNumber.Text);
    }
    set
    {
        txtNumber.Text = value.ToString();
    }
}

Then I just played with the styling a little with a slight highlight on the top and the like.

Next, I created a FlippingNumber control that would be the base for the various numbers on the clock. To make it look right,  I actually needed 4 sections to the control. Two to show the current number and two to show the next number and we flip between them. I simply put two of the top and two of the bottom number controls one the page. The flip was just an animation similar to the flipping of the two images in the top of the badge. The only difference is that I skewed the controls a little to give it a slight 3d effect.

Once that was done, the rest of the number was built in code.

public FlippingNumber()
{
    InitializeComponent();

    FlipDown.Completed += new EventHandler(FlipDown_Completed);
}

void FlipDown_Completed(object sender, EventArgs e)
{
    numBottomBack.Value = _val;
    numTopFlip.Value = _val;
}

int _val = -9999;
public int Value
{
    get
    {
        return _val;
    }
    set
    {
        if (value != _val)
        {
            _val = value;
            numBottomFlip.Value = _val;
            numTopBack.Value = _val;

            FlipDown.Begin();
        }
    }
}

The other property that I added was so that the clock could adjust the speed at which the number flipped.

public double SpeedRatio
{
    get
    {
        return FlipDown.SpeedRatio;
    }
    set
    {
        FlipDown.SpeedRatio = value;
    }
}

Finally, I was ready to piece together the clock. That was a simple matter of placing 6 of the flipping number controls on the clock face. All that was left was set the time on the clock based on a value in the passed in TimeSpan.

TimeSpan _timeSpan;
public TimeSpan TimeSpan
{
    get
    {
        return _timeSpan;
    }
    set
    {
        _timeSpan = value;

        numSecondOne.Value = FirstCharacter(_timeSpan.Seconds);
        numSecondTwo.Value = SecondCharacter(_timeSpan.Seconds);

        numMinuteOne.Value = FirstCharacter(_timeSpan.Minutes);
        numMinuteTwo.Value = SecondCharacter(_timeSpan.Minutes);

        numHourOne.Value = FirstCharacter(_timeSpan.Hours);
        numHourTwo.Value = SecondCharacter(_timeSpan.Hours);
    }
}

private int FirstCharacter(int num)
{
    string s = string.Format("{0:00}", num);
    return int.Parse(s.Substring(1, 1));
}

private int SecondCharacter(int num)
{
    string s = string.Format("{0:00}", num);
    return int.Parse(s.Substring(0, 1));
}

The last thing on the badge that I did was change the timer control code on the overall blog badge to pass the time span into the clock face rather than parsing it into textboxes.

Now I wanted people to be able to use it from their own blog. To allow that to happen, I needed a put together a cross domain policy via the clientaccesspolicy.xml file.

<?xml version="1.0" encoding="utf-8"?>
<access-policy>
    <cross-domain-access>
        <policy>
            <allow-from http-request-headers="*">
                <domain uri="*"/>
            </allow-from>
            <grant-to>
                <resource path="/resources/SilverCountDown.xap" include-subpaths="true"/>
            </grant-to>
        </policy>
    </cross-domain-access>
</access-policy>

Notice that I’m allowing access from any domain but restricting access to only load the specific xap file.

Anyone who wants to put it on their blog can do so simply by leveraging the following object tag.

<div id="silverlightControlHost">
    <object data="data:application/x-silverlight," 
          type="application/x-silverlight-2" width="100px" height="200px">
        <param name="source" value="http://www.joshholmes.com/resources/SilverCountDown.xap"/>
        <param name="background" value="white" />
        <param name="minRuntimeVersion" value="2.0.31005.0" />
        <param name="autoUpgrade" value="true" />
        <a href="http://go.microsoft.com/fwlink/?LinkID=124807" style="text-decoration: none;">
             <img src=http://go.microsoft.com/fwlink/?LinkId=108181 
                  alt="Get Microsoft Silverlight" style="border-style: none"/>
        </a>
    </object>
    <iframe style='visibility:hidden;height:0;width:0;border:0px'></iframe>
</div>

Feel free to place the badge on your own blog to help promote RIAPalooza – When this year finishes, I’ll update the counter with next years dates as soon as we know it… :)

Also – I put the code up at http://www.joshholmes.com/resources/silvercountdown.zip. Feel free to take it and play with it.