It seems that most people fall in the latter category.  I’ve already spoke to a number SDNers from all different industries who see how they can use this type of interface in a broad range of applications.  A airplane manufacturer navigating large engineering drawings to business people visualizing data sets in 3d to see patterns.  This was the reaction we were hoping to create in the community a true sense of innovation and possibility.  It’s also been a blast watching people mess around with the interface.

Here are some great photos from hacker night with Mark Finnern and Marilyn Pratt messing around with Majority Desk.

The point was to learn how the applications are structured and then see if I could add an existing application back to the iPhone with a different name and icon and have it run. Today Fred and I set out to see if we could get this to happen.

iPhone applications look very similar to applications for OSX, makes sense as they both run some version of OSX.  The file structure of the iPhone Calculator is this:

[/Applications]
    [/Calculator.app]
        Calculator
        CalculatorBackground.png
        Default.png
        [/English.lproj]
            InfoPlist.strings
            Localizable.strings
        Info.plist
        LCDBackground.png
        PkgInfo
        icon.png
        ring.png

[ source: iPhone Directory listing ]

For this example we will be trying to change the calculator app into some a touch more fun looking.  First step is simple ( if you already have SSH on the iPhone and the binkit on your iPhone)  tar up the Calculator app and copy it to a Mac.

Executable [Calculator]

The Calculator file is a compiled binary for the ARM platform running it from OSX produces the error message: “Bad CPU type in executable.”  We assume that this has something to with the Universal application concept in OSX.  It is opening that executable and looking to see if it has the ability it talk to an Intel/PPC processor it of course doesn’t so it craps out.  First thing we did was to rename this file to foobar.

Info.plist

This is the file that has all the information about what to execute when a user clicks on the icon in the home screen.  File is a regular plist file from normal OSX applications.  The node to concern yourself with is CFBundleExecutable.  This points at the binary you want to execute.  So, in our case we need to point this node at our renamed executable.

icon.png

A few sites have already figured out you can change these around so, I won’t go into anymore detail then pointing you at the ModMyiPhone wiki that describes the structure of iPhone pngs.  You don’t actually need to “optimize” your pngs for your iPhone.  It can render regular ones just fine.  We threw a “festive” graphic into our package.

“Deploy”

The final step is to move all these files over to the iPhone.  Make sure you get the directory structure right:  /Applications/foobar.app/ .  Reboot the phone and you should see your newly renamed and functioning Calc application on the home page.

One other interesting that came of this is that the iPhone can’t have more then 16 applications on it.  The home screen does not have the ability to scroll.  We loaded 4 more copies of the calculator onto the phone and were unable to scroll down to see them.  Maybe there is a simple change to the launcher application to allow the scrolling to happen or maybe Apple has to change the application to allow it.

You can see the little Handbrake icon peeking out from under the Buttonbar, but you can’t scroll down to see it.  Sad.

No, this isn’t a new native application but, it gets us one step closer to deploying applications onto the iPhone once we can compile them, which is still a long way off.

Labelling things enterprise, business or even professional enables a defence of complexity that shouldn’t be tolerated without a challenge.

People log on to consumer tools because they want to, but often they log on to enterprise applications because they have to. I don’t think this should be an excuse to expose them to any more complexity than absolutely necessary

I wondered when I read this if making the tool simpler is the correct path.  Maybe we can learn a lot from a company like Adobe — they have never made Photoshop any easier to use.  It is incredibly powerful and incredibly hard to use, just do a Google search for “photoshop training” and “SAP training” and you may start to see the correlation — approximately 265k and 270k respectively (obviously wholly unscientific but, with a research budget of zero, that’s what you get). 

“Use(full|less) Intro”

Lots of video games have totally useless and uneventful intro levels.  Learning how to jump, run and fire your weapon, etc.  Could it be possible that Adobe has done a good job of introducing the Photoshop tool set to it’s customers before they actually decide to go and spend the large amount of money on the big software package?  I can honestly say that I don’t know if Adobe does this, do you slowly work into the larger Photoshop toolset from the other available Adobe applications?  Is there some really great indoctrination path for Adobe tools?  Maybe they have some brainwashing secret sauce that SAP could get.

Casual Users = Consumer Users

If you are at all interested in UI you should go buy Design of Everyday Things by Donald Norman.  In it Norman talks about putting information into the world so that occasional users can have visual and physical clues about how to make your system work.  If you keep up with Seth Godin, he mentions a similar concept in marketing, “Be obvious about it. A sign that says First Time Here in three or four languages is a fine place to start. You can explain that while you serve minestrone, the locals come for the gumbo.”  This all combines into making the system usable for the people who only use it occasionally.  Norman also, talks about how you have to have an understanding of what people are going to use your object for before you set on the task of designing it.  Again, however, Seth has an interesting real world comparison.  Why aren’t stores organized to help us shop and help us buy things: 

So, all the Armani blue suits are next to each other, then by size.

So, all the boxer shorts at the Gap are on a wall, organized by style first (checks over here, stripes over there,) then by size.

So, all the power tools at Home Depot are together, sometimes by brand, sometimes by function (saw) and then by type of material to be cut (wood).

This is dumb, and the web makes it obvious why it’s dumb. It’s dumb because it makes it easier for the clerk, not for the customer. And dumb because it plays to the label’s ego, not to ours.

Does anyone say, “okay, even though my son wears size large boxers, these striped ones are really nice, I’ll buy the small instead.” Of course not.

So why not put all the large boxers right next to each other, regardless of designer and style?

Amazon and Google are designed with both these concepts in mind.  Google has 1 box and 1 button.  When you are searching you have something in your mind to type.  Well, that goes in the box.  With only one button on the screen, well human nature just forces you to push it.  Amazon does a stellar job with the latter case, you just bought a pair of shoes, other people who bought that pair of shoes bought these socks.  Simple?  Yes.  Easy to do?  No.

Who are “they”

Photoshop is made for people who already understand Photo editing — it uses terms they understand and have used for years in moving from the ranks of Amateur to Professional.  It puts those terms and arranges those buttons to support those Professionals’ normal mode of working.

This may force us to rethink how we target Business applications.  Are “business users” (thanks for the cringe Thomas) true professionals, like our Photoshop fans or are they people who move between jobs being novices in lots of areas.  Should be be designing tools to indoctrinate people into our toolset and transform them into a professional?  Or are they always going to be casual users of the business tools simply consuming them as they flow through our enterprises?

Thanks to a great tip from Matt Chotin, from Adobe, in the comments of my previous post I take a massive step forward in the UI department.  Again, the Open Source gods ( is this open source? ) work their magic to give me an even more useful component:  SpringGraph from another Adobe Engineer ( seeing a pattern are we ) named Mark Shepard.  He hasn’t blogged in some time, so I’m not sure he is still doing stuff with Adobe/Flex or blogging but, his component totally rules and fits my needs pretty closely.  Here is the original SpringGraph Demo and the Roamer Demo which is like the SpringGraph just with nodes hidden or collapsed ( which may be the final component I use ).  Well onto, what I’m trying to do:

Shiny New Object

First things first, time to see what makes the SpringGraph tick.  Given my limited knowledge of all things Flash, I had to piece together how the main body of his MXML file even worked. 

<fc:SpringGraph id="s" backgroundColor="#ffffff"
    lineColor="#333388" left="0" right="0" top="0"
                    bottom="0"
                    itemRenderer="AmazonItemView"
                    repulsionFactor="{rep.value}"
    >
</fc:SpringGraph>

It took me a few minutes to understand the beauty of the itemRenderer system built into Flex.  If you check out the other source objects in Mark’s project you will notice AmazonItem.as and AmazonItemView.as.  Think of this as a mini MVC subsystem.  With a collection of AmazonItem-s being the model, the SpringGraph control being the controller and the AmazonItemView obviously being the view.   This is made clearer when you add the following AS3 snippet to the mix

private var items: Graph;
public function addItem(id: String, name: String,
               linkTo: AmazonItem): AmazonItem {
    var newItem: AmazonItem =
               new AmazonItem(id, name);
    items.add(newItem);
    if(linkTo != null)
        items.link(newItem, linkTo);
    s.dataProvider = items;
    return newItem;
}

What is happening here?  Well as you call the addItem function an instance of the model, AmazonItem is created and added to collection.  This collection is then bound to the dataProvider of the SpringGraph.  When SpringGraph is drawn on the stage it loops at this dataProvider and instantiates a view object named itemRenderer for each item in the dataProvider.  So this allows you to completely change what the SpringGrid is rendering on your behalf — pretty cool, huh?

My “Model”

Now that I think I understand how that component works I need a place to store some data about a Twitter user.  Normally, you could just create a basic class and use that but, in the case of this component it seems you need to subclass the delivered Item class.  Once again, no big deal.  Created a new class called TwitterPerson.  That class has a few attributes:

public class TwitterPerson extends Item
{
    [Bindable]public var screenName:String;
    [Bindable]public var name:String;
    [Bindable]public var profile_image:String;

These will store the data returned from the API, I’ve named the attributes nearly the same as the API to make it easier to follow.  The attributes are bindable so that as I fill in the information the “view” will update automatically.  The constructor is uber-simple:

public function TwitterPerson(xml:XML){
    screenName = xml.screen_name;
    name = xml.name;
    profile_image = xml.profile_image_url;
}

To make it as easy as possible to construct the TwitterPerson I just pass in an XML node and map the parameters myself.  If you check out the API you will see that the two services I use “statuses/friends/” and  ”users/show/” return different data but have the same information about each person with the same attribute names ( thanks for the consistency Twitter guys! ).

My “View”

The other piece I need to construct is the view that the SpringGraph will call to render the data stored in the model.  For right now all I want to do is put the picture of the person being rendered up there and give a tool tip for their name.  Flex makes something like this so easy it’s barely worth mentioning but for completeness:

<mx:VBox xmlns:mx="http://www.adobe.com/2006/mxml">
    <mx:Image source="{data.profile_image}"
        scaleX="1" scaleY="1"
        toolTip="{data.name}"/>
</mx:VBox>

Two Heads are better then one but One’s a start

Back in the main MXML of our application things have changed a bit:

<mx:HTTPService id="myInfoService"
    url="http://twitter.com/users/show/dan_mcweeney.xml"
    resultFormat="e4x"
    result="onMyInfoServiceResult(event)"
    fault="onMyInfoServiceFailed(event)"
/>

<fc:SpringGraph id="springLayout"
    backgroundColor="#ffffff" lineColor="#333388" left="0"
    right="0" top="0" bottom="0"
    itemRenderer="TwitterPersonView"
    repulsionFactor=".80" canDragNodes="false"
/>

You can see how nice and clean the SpringGraph is to use it was basically a one for one swap of other component.  Another change here is method used to fetch the data.  As you will see in the next section I leave it up to the Model class itself to determine how their friends are, hopefully this will be a good decision architecturally, so the start of the application is to just call the send method of the myInfoService HTTPService.  The result event is then triggered and that’s where everything gets stuck back together again.

At this point if you are following along, which I’m fairly certain no one is, you should get one head floating in the middle of a big white background, yay!  Although the astute observer will notice that I snuck a new method into that last snippet of code: “person.getFriends()”. 

Model^2 Math.pow(Model,2)

As I mentioned eariler I have now moved the getting of friends into the Model.  I did this to hopefully make it easier for some ideas I have in the long run but also to see how to make a HTTPService entirely in AS.  All this method does is ask the Twitter API to for the user’s list of friends:

 1 public function getFriends():void{
 2     var friendsService:HTTPService = new HTTPService();
 3     var friends:Array = new Array();
 4     friendsService.url =
 5        "http://twitter.com/statuses/friends/"  +
 6        screenName + ".xml";
 7     friendsService.resultFormat = "e4x";
 8     friendsService.addEventListener(FaultEvent.FAULT,
 9         friendsFault);
10     friendsService.addEventListener("result",
11         friendsResult);
12     friendsService.send();
13 }

The only remaining mystery is what happens in the friendsResult method which gets bound to the “result” event on line 10-11. 

private function friendsResult(result:ResultEvent):void{
    var friendsArray:Array = new Array();
    for each (var userEntry:XML in result.result.user){
        friendsArray.push(new TwitterPerson(userEntry));
    }
    sevenDegress_2(Application.application).
          onAddFriends(this, friendsArray);
}

When the friends HTTPService returns it has a list of all the user’s friends and their current status.  The method just pushes these newly minted TwitterPerson(s) into an array and then calls another mysterious method from the application that contains it.  I don’t know if this is the best way to do this or not — seems like a bad case of statically linking these two objects but it seemed like the easiest way at the time.  This line of code gets the root Application object’s attribute called application and invokes a method on it.  For this to work at compile time though you need to cast that application attribute over to to the specific type of your application hence that funky, sevenDegrees_2 thing you see there.  The source code to that one extra method is also pretty straightforward thanks once again to Mark’s Graph class:

public function onAddFriends(node:TwitterPerson,
        friendsList:Array):void{
    for each (var person:TwitterPerson in friendsList){
        people.add(person);
        people.link(person, node);
    }
}

When the friends HTTPService gets a result it passes it back up to the application which in turn modifies the data provider by adding the new nodes ( via the add() method ) and then linking them to each other ( via the link() method ).  This should now produce the pretty little Poof ball like below:

Hatchet Attack

This control is actually a little too useful for my needs, I don’t really want anyone to be able to drag folks around once they have been placed on the screen so, I have to delve into Mark’s control and get rid of that functionality.  This turned out to be a fairly straightforward:

 1 private function mouseDownEvent
 2        (event: MouseEvent):void  {
 3     var now: int = getTimer();
 4     if((now - lastMouseDownTime) < 300) {
 5         // it's a double-click
 6         var node: GraphNode = _dataProvider.findNode(
 7                 UIComponent(event.currentTarget));
 8         if(node != null) {
 9             dragEnd(event);
10             if(Object(node.view).
11                 hasOwnProperty("doubleClick"))
12             Object(node.view).doubleClick(event);
13         }
14         return;
15     }
16     lastMouseDownTime = now;
17     if (_canDragNodes)
18         dragBegin(event);
19     event.stopImmediatePropagation();
20 }

Beyond the addition of line 17, the only other thing I needed to add was one parameter _canDragNodes ( and its’ getter and setter methods ).  Although it is truly tons of fun to drag the seed member of the graph around and watch all their Twitter Friends fly after them — it’s not really useful.

If you want to see it running live, meaning you really think I’m a liar, here is a link to the Current Version of 7DegreesOfTwitter.

I also have wanted to build a Twitter ( hanger-on ) application that shows you your web friends and their friends and their friends and so on — think 6 Degrees of Kevin Bacon but, for Twitter.  I’ve thought about the visualizations for this and feel that Flex/Flash is the only way to go, which I luckily no nothing about!  So, tonight is the first episode of stuff I wish I knew about Flex while building 7DegreesOfTwitter.

I will only be working on this at night and on the weekends so, progress will be slow and sometimes painful.  I may even try and post nightly “builds” somewhere so people can see what I’m up to help give me pointers where required.

A Plan

Here is what i think the visualization should look like ( yes this was done in MS Paint, hopefully I am a better programmer then artist ):

Basically, you should see all your friends circled around your portrait then as you click on a friend it will shift the view so that your friend is now the focus on the screen, and you can move along your web of friends exploring other people’s connection.  Obviously, this whole visualization is rife with opportunity.  Adding some cool like the Mac doc magnify feature would be pretty cool, or even maybe have the whole thing look like a horizon instead of a flat web of people.

First Day 

First thing to do is get two chunks of data out of Twitter using the Twitter API.  The first bit is your list of friends:

    <mx:Script>
        <![CDATA[
            import mx.rpc.events.FaultEvent;
            import mx.rpc.events.ResultEvent;
            public var myInfo:XML;
            public var friends:XML;
            private function onFriendsResult(result:ResultEvent):void{
                friends = XML(result.result);
            }
            private function onFriendsFault(result:FaultEvent):void{
                var error:XML;
                error = XML(result.fault);
            }

        ]]>

    </mx:Script>

    <mx:HTTPService id="friendsService"
        url="http://twitter.com/statuses/friends/dan_mcweeney.xml"
        resultFormat="e4x"
        result="onFriendsResult(event)"
        fault="onFriendsFault(event)"/>

So basically, this is all it takes in Flex to get data from a web service and parse it into an XML document that is easily traversable.  If you don’t know what E4X is neither did I — go read the Wikipedia entry about E4X then have a look at the W3Schools Tutorial on E4X.  Just remember it’s actually a lot easier then you think, no big scary XSLTs here.  The next thing to do was the other piece of data I need, in this case it’s your mug shot associated with your Twitter account:

<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute"
creationComplete="friendsService.send()">
    <mx:Script>
        <![CDATA[
            import mx.rpc.events.FaultEvent;
            import mx.rpc.events.ResultEvent;
            public var myInfo:XML;
            public var friends:XML;
            private function onFriendsResult(result:ResultEvent):void{
                friends = XML(result.result);
                myInfoService.send();
            }
            private function onFriendsFault(result:FaultEvent):void{
                var error:XML;
                error = XML(result.fault);
            }

            private function onMyInfoServiceResult(result:ResultEvent):void{
                myInfo = XML(result.result);
                myMug.source = myInfo.profile_image_url;
            }
            private function onMyInfoServiceFailed(result:FaultEvent):void{
                var error:XML;
                error = XML(result.fault);
            }
        ]]>

    </mx:Script>
    <mx:HTTPService id="friendsService"
                    url="http://twitter.com/statuses/friends/dan_mcweeney.xml"
                    resultFormat="e4x"
                    result="onFriendsResult(event)"
                    fault="onFriendsFault(event)"/>
    <mx:HTTPService id="myInfoService"
                    url="http://twitter.com/users/show/dan_mcweeney.xml"
                    resultFormat="e4x"
                    result="onMyInfoServiceResult(event)"
                    fault="onMyInfoServiceFailed(event)"/>
    <mx:Image id="myMug" source="" horizontalCenter="0" verticalCenter="0"
                     width="48" height="48"/>

</mx:Application>

Major additions here are a a new HTTPService to grab my information and also a small slight of hand to keep the two asynchronous services at least somewhat in sync.  In the onFriendsResult function I call the next HTTPService.  This is an easy way to create simple dependencies among asynchronous requests.

The Layout

I started tonight to try and write this myself — and I soon realized I was probably in over my head.  I got up to the point where I am able to calculate the correct radius for a circle to easily hold all of the objects and then where their positions should be in radians around the circle.  The thought of having to write this in Flex made me want to jump out a window, so I thought to myself — maybe someone has already done this. Just then the Red Sea was parted and the open source gods smiled upon me.  Circle Layout was created by Sho Kuwamoto, an Adobe Engineer, it does exactly what I want in terms of layout and some other snazzy stuff with drag and drop.  Here is a demo of the Circle Layout for Flex just press the “Change to Circle” button to see what I am talking about.  It’s a pretty impressive bit of code for my needs though I need to get rid of the drag and drop bits but, for right now I will leave all that in.

So here is the the running code for Iteration 1 of the 7DegreesOfTwitter.  If you want the source just right-click the movie and use the “View Source” menu option.  When asked for a username and password just use your Twitter Log-in info.

Current issues:

• Only works for me!
• No clue what will happen when you have lots of friends

Next time?

• Create a hover over for the images to at least show the name
• Come up with a way of Clicking on a person then moving to their “circle”

If you find more issues in the code just post a comment — if I’m doing something totally silly please tell me that too!

Once again big thanks to Sho Kuwamoto for saving me having to do any real programming

View from the cheap seats

If you believe SAP’s vision of the future, the next version of the enterprise will be most certainly be YouTubed. Yesterday, Hasso worked off a set of great blackboard styled slides (anyone have that font?) and even brought one of his classes to the keynote. In his usual way, Hasso cut to the chase about the shifts occurring in enterprise software due to technology and the advent of the social web. Building off Thomas Otter’s live notes and Cote’s mind map here are some thoughts about the keynotes viewed as a whole.

New Idea

His solution to these shifts is his “New Idea” an architectural change focused more on “clouds” that could be used as raw computing power and potentially house enterprise services. The new architecture needs to be event based, must focus on the end user of the application, should be model based and expose little to no code. Probably, the most interesting point here is the idea of event driven thinking.

The “information worker” does not do the same transition repeatedly. They seek out exceptions they look for trends. Part of refocusing on the user will have to allow these users to more affectively locate these fringe events and resolve them. I would also love to see SAP start tracking the root cause of the error — what series of events occurred prior to this issue? Next time could we prevent it? We of course first have to come up with a way of attaching all these systems and getting them talking.

The answer of course is SOA! Hasso does add another interesting spin to this through higher degrees of abstraction allowing a fully model based architecture to enable user to model everything. Obviously, all this is probably still only on the blackboard but, one can see a time with these standardized clouds of services available at will and the ability to have a crowd sourced documentation scheme maybe capable business users could really start to remodel their own enterprise.

Community

Around the community topic Hasso said, “Without a community there is no product,” which is a great hat tip to the folks on SDN /BPX and certainly an important focus for the company moving forward. The idea of using this community to create feature requests is an obvious next step. SAP is only just starting to use their BPX communities to create ES, imagine a time where the users were modeling processes and even changing UI constructs to suit a particular need or usage pattern. This is sort of the holy grail of adaptive UI but uses a crowd sourced to determine the layout and functionality, no need for complex coding!

SAP software generally overlooks the casual users. Hasso argues that these people need to have the UI adapt to their needs as they progress from casual to expert. I’m not sure what this interaction model would look like certainly the hidden menu items in MS Office(before Vista) is not the best way. The idea is great if you can come up with a way to have the UI flex to the user based upon their own knowledge level.

UI

Not all of this appears to be blackboard magic; during Henning’s keynote he “demoed” a prototype of a Web 2.0-ey workspace for business users. This was also shown on the floor also, it has many more features, such as connections to mobile users via Blackberry and having them email into the space to contribute to the project. The general idea of the UI is to allow users to bring people in the space to solve a particular problem. You can add a user to the space, assign users to a task, and use a wiki to help organize the new ad hoc team. The framework supports the notion of templating so you can branch off to do a repetitive transactional type task injecting a good flavor of “best-practice.”

Finding others to help in these new ad hoc teams is easy with Harmony. Harmony is a mySpace/LinkedIn kind of application for the enterprise. It is already running at SAP and I’ve already had some hands on time with it. The interface is very good, has a consistent UI and well done graphics – the whole package looks highly, well unSAPish. The current version only has the mySpace component but I hope they plans to add the other components, wikis, blogs, social bookmarking, etc. This is SAP’s first foray into the social computing side of web 2.0 so no surprise the offer is limited. On the live SAP site you already have started to see interesting groups form like Basketball leagues and Live Music Lovers, not a huge value to the enterprise’s bottom line but happy workers are more productive workers.

Harmony UI

With the addition of a social computing slant, you really start to see the underlying strategy of the user-generated enterprise, at least that was my take on the whole thing.

I think Google’s next move as Jason, astutely observes is to create “reoccurring revenue” for PC makers like Dell/HP by getting them to install something that isn’t MS Windows, however that something won’t be a Google OS. It will more likely be an Open source OS like, Ubuntu with a revived Google Pack installed on it. I think the simple reason for this is Google has been involved in Linux development for a long time but, in the area of the kernel not on the front end. Why should Google do any work when they can just piggy back on another great initiative.

The pack will have to have some interesting additions to really put the squeeze on MS. I think the obvious choice is “your desktop PC anywhere you are” — the current notion of “your” PC will become irrelevant, meaning, having everything on one piece of hardware you own won’t matter. You can see Google starting to do this now with Google Applications. With the addition of the elusive G-Drive mounted as a “virtual HD” sprinkled into the “Pack” you have a very flexible totally portable desktop environment. Imagine going to any machine in a business and signing in and getting all your preferences, all your documents, installed programs, right there for you! The great part about this it wouldn’t cost Google much, as they would be using currently available OS solutions, FF, Linux, etc. As more people buy PCs with the “Google OS/Pack” on them, more people will reap the benefits of the “anywhere desktop,” creating a runaway snowball effect.

So, I don’t think Google will build an OS in the strictest sense, I think they will extend existing technologies, the Linux desktop out to a their servers and their incredibly powerful data centers down to the desktop.

SAP user’s of today are people that can remember a time when computers were the size of small city blocks and the idea of having one on your desk was laughable[1]. Most of them are happy enough to have a computer on their desk to run Excel and mess with their own spreadsheets. These people today control the purse strings of IT spending and are “leading” the relationship with SAP. This is bad…. why? I’ll talk about that later.
If you have a child who is less then 30 years old and you work in an IT shop that runs SAP software, you should be scared. Talking from my personal experience ( I am 27 years old ) my family got their first computer when i was 6 or 7, I can just barely remember a time Before Computers, what this means to me and everyone in my age bracket is that we have used computers forever, our expectations are different. How different can be quickly mapped as you go down generations, the younger you start to use computers the higher your expectations are. I can’t stand when Ctrl-C doesn’t work or when I can’t turn on and off toolbars or when the screen is so full of information I don’t need all I can see is a box 200px by 150px. When this happens I go find another tool — this is why you should be scared.

Thomas Otter points out that at SAP they are good at process — it sounds almost like a core value,

“at SAP we think a lot about processes. I hear it all the time in the corridors and meeting rooms in Walldorf. It is one of the main reasons for SAP’s success. It is goodness, and it is very tough to emulate… It is a significant competitive advantage.”

This is all quite true they do have that “special sauce” down to a ‘T’ however, it won’t help when folks in my generation start to take control of the purse strings.

If someone gives me a piece of software I “must use” and it is horrible, the first thing I do before using it is to see if there is another tool I can quickly use the way I want and then just plug the numbers into the horrible tool. This is a huge problem for SAP as that all the wonder process focus Thomas talks about goes out the window when people don’t use the tool in the manner it was designed. I would argue that for the next generation of people who will soon ( < 10 years ) start to get into decision making positions at Fortune 1000s UI ease and flexibility will be nearly as important as all the process stuff already boiled into SAP software.

As campy as Time’s person of the year was, it was about a change of focus on the internet. From just a push of information and goods out, to a true conversation. People creating content to be consumed by others, the internet as just another conduit for people to carry out conversations. This change of focus needs to be felt in the Enterprise too and I am concerned we might not be able to move fast enough.

[1] “There is no reason for any individual to have a computer in his home.” — Ken Olson, president of Digital Equipment Corp. 1977 ( Snopes )

1. Agile Development
• Im totally guessing here, but in most IT shops I assume you probably use some locally bastardized version of the Waterfall method. In our R&D team we use an over simplified version of Scrum, the idea is to remove all the unnecessary artifacts from the process and “Shutup and make it work,” to use one of our teams mantras. The basic idea is get testable code in another team’s hands as frequently as possible; this could mean every night or every week.
• The reason this is number one is that it will allow you ( and/or your team ) to prove value instantly. People go nuts when you deliver the 1st version of working code before other teams have even decided who writes the spec
• Using this type of process automatically distinguishes you from your colleagues, it allows you to move fluidly with the ever changing IT landscape, it is a huge win over your normal process and a big key to my team’s success
2. Flatten your Team
• This may seem like a no brainer but odds are there are lots of people between you and your user community. To be successful at delivering code as fast as you will need to justify your spent time you must be as close as possible to your user base. This means you can’t have a rigid structure the person who knows the most about the area needs to make the decisions. Suck up your pride and let them run the show.
3. Get smart people
• I have a really hard time phrasing this statement but, suffice to say, you have to get the cream of your organization. If you want someone to go decide if Ruby on Rails is a good idea you better trust that person’s ability to learn and their ability to judge technologies. In the end it’s better to have fewer people then an army of people you have to micro-manage.
4. Research is failure
• This is one of the hardest concepts for an IT shop to grasp — they mostly deal with uptime and throughput but when experimenting with new ways of doing things you have to be able to deal with a certain amount of risk and this finally brings me to the reason for this blog, a recent post ( really go read it ) by Carmine Coyote at Slow Leadership, really a great job about the fear that makes these teams fail. Which brings me to my last point
  
5. Fear Nothing
• You can’t be a “disruptive innovator” ( thanks Shai ) without risking something every once in awhile
• Make your management understand that fear is costing them $
• “Thrill your users” ( thanks again Shai ) any fears your management has will go away

Good luck, if IT in the US is to stay we must stop being a commodity and start delivering really measurable value to our businesses again. The simplest way to do this in the enterprise space is to simply make those ugly back end systems usable.

btw — this blog was written somewhere south of Greenland at about 33k feet. On board internet is great.