How many times have you seen the latest technology injected into a project, used for the duration of a feature / release, and then left to whither?  I've seen it more times than I'd like, and it's got to stop.

Don't get me wrong.   I love new technology -- a lot.  I love learning how it works, and I love to figure out where it's appropriately used.  I also know that you can't just throw new technology into a software project without a plan, and yet I see it happen over and over.

Last week, I saw someone try to shove Entity Framework into a project on the sly, as if nobody was going to notice.  Chaos ensued when this plan blew up, and repairs are now being made.  The bungle itself was alarming, but I was even more disturbed to reflect on how many checks and balances were already blown before the right people learned what was going on, and why it was a bad idea.

This is a failure on multiple levels.

First, developers themselves should know better than this.  The reason EF was chosen in this case was nominally because it was supposed to help the team deliver a feature more quickly.  As developers, we've all seen this argument fail dozens of times, and yet we fail to learn our lesson.  New technology certainly improves our craft over time, but the first time we use any new tool, we run into teething problems.  If we grab a brand-new, shiny box of tech goodness off the shelf and honestly think that it's going to work perfectly the first time we plug it in, we should be hauled out back and bludgeoned.

Next failure: architectural guidance.  In this case, there exist architectural standards that cover data access, so at first glance, it would appear that this is an open and shut case.  In practice, though, the standards are very poorly socialized, and they're badly out of date.  In short, they have the appearance of not being relevant, so it's easy for developers to discount them.  Architectural standards need to be living and breathing, and they need to evolve and grow so that designs can adopt new technologies at a measured pace.  To do less than this is to erect a static roadblock in front of developers.  The developers will drive around it.

Finally, management allowed this failure in a couple ways.  Early in this process, a dysfunctional conversation occurred.  Management needed a feature by such-in-such date.  Development thought this wasn't nearly long enough.  Wringing of hands and gnashing of teeth ensued, and eventually, the developer capitulated, claiming that we could make the date, but only by departing from our normal development standards and using this new tech tool instead.   Some form of this conversation has been responsible for more software disasters than I could count.

No matter how much time we put into defining our processes, no matter how many years of experience we draw upon, and no matter how many times it's proven that shortcuts kill, we keep getting suckered into them.

Personally, I draw a couple of conclusions from this.  First, we just need to have a little more personal integrity and discipline.  That's sort of a cheap shot, but it's true.  The second conclusion, though is more of a reminder to us as an industry: if we're so desperate that we'll take long shots like this, despite the odds, then the state of the industry must be pretty bad, indeed.  As an industry, we need to acknowledge that we're causing this sort of reaction, and we need to find a way to be more productive, more reliably.

But not by throwing out the process just when we need it most.

Related articles by Zemanta

• The Evolution of a Scrappy Startup to a Successful Web Service (slideshare.net)
• PHX Session #5 : Architecture Without Big Design Up Front (Garibay) (slideshare.net)
• Delivering products in agile (Smart) projects (sanderhoogendoorn.org)

Here's your free management tip for the day: get out of your chair and go see what's happening on the floor.

Every summer, I go to Boy Scout summer camp with my son.  Although this passes for vacation, it invariably ends up being a management clinic.  You might think you see where I'm going with this: chasing 30 Scouts around is just like chasing developers, right?

But that's not actually what I had in mind.  My real job at summer camp is to remove obstacles for the kids.  They're at camp to earn badges, and it's amazing how many trivial problems pop up and totally confound either the kids or the camp counselors, who are also kids.  Left to their own, both the Scouts and the counselors can be expected to churn on these problems, waiting for them to fix themselves.

I've seen counselors, for instance, find themselves without some tool or supply they need to teach a class, and they'll just wait for the tool fairy to drop by and bestow upon them a brand-new left-handed clipboard, or box of triple-gussetted ziplock bags, or whatever they're missing.  In the mean time, Scouts sit idle because they can't get their work done, and badges are not earned.

Other problems occur as well: sometimes there are disruptive students; sometimes the counselors don't know the material they're supposed to teach; sometimes kids aren't paying attention to work they're supposed to do outside of "class" time.  In all these cases, though, if you're sitting back at camp asking kids how they're doing, they'll all tell you things are great -- right up to the end of the week when they don't get their badges.

Now, it's true that some of these problems would eventually sort themselves out, but probably not in time for most of these kids to catch back up again.  I consistently find that if I spend time checking out classes myself, I can spot problems and take them to someone who can help, and we can get small issues turned around before they become large issues.

What's the lesson here for a software manager?

First, I'm not suggesting that you hover behind someone's desk so you can swat them when they stop coding.  I'm talking about finding the real obstacles to effective development and addressing them.

You might find that your developers need better equipment.  You might find that the requirements they're working from are woefully inadequete.  You might find that servers they depend on are slow or frequently down.

But don't limit your observations to developers only.  Check out the help desk.  This is one of the best sources for information about how your software is really performing.  It's one thing to read about a problem in a help desk ticket, but it's another thing altogether to observe your customers' emotional reaction to problems with your software.  Similarly, watch your software in use by real customers, or by your operations team, and you'll gain a new appreciation for real-world usability and performance.

When there's something wrong with your software, you'll probably learn about it eventually through your TPS reports, but you can keep an awful lot of small problems from becoming big problems by getting out there and looking around.

Apple has been the undisputed darling of electronics marketing since the introduction of the iPod.  Everything they touch turns to gold, and they've built the mystique of the Apple brand into a legendary golden goose.

But it's been a tough week for Apple.

People have been grumbling about the arbitrary and seemingly random approval process for apps on the iPhone, but the applesauce really hit the fan this week when Apple revoked apps that work with Google Voice app:

There's No App For That

This has set off a small firestorm among developers:

• I Quit the iPhone (Michael Arrington)
• Seriously, What is Going on with the App Store? Blocks, Delays, and Awful Apps Slipping Through (ReadWrite Web)
• stevenf.tubmlr.com

Is this the beginning of the end for Apple?  Probably not.  This isn't the first time Apple has made some consumers mad, but there's only so many times they can pull stunts like this before it starts to catch up with them.

Related articles by Zemanta

• Google Voice Debacle Causes Arrington to Ditch the iPhone, and With Good Reason [IPhone] (gizmodo.com)
• Fed Up, A Popular Mac Developer Quits The iPhone (techcrunch.com)
• Apple's Chickenshit Approval Process Has Gone Too Far [Apple] (gizmodo.com)

"Release early, release often."  This is the Web 2.0 mantra, and it's also a major guiding principle behind agile development proceses.

In product development, conventional wisdom has it that first-to-market- or first-mover advantage is hugely important.  But for software products, this can kill you by painting your product into a corner from which it never recovers.  Just about every software product is burdened with backward compatibility issues, and for many products, compatibility is paramount as customers create files with these products, integrate them into their environments, and come to depend on the software acting the way it does.

With its very first release, then, a software company can find itself wearing an anchor.  Let's look at some examples.

Microsoft Windows

Windows is the definitive example of a product that's become hamstrung by backward compatibility.  Compatibility was one of the things that killed Vista.  It turns out that you can only slap so many coats of paint over a dry-rotted wall before you need to rebuild the frame.  Even security (another noted weakness) would be better if Microsoft had really had the option to start over.

In the mean time, Apple was able to come out with a fresh operating system, and they're now cleaning Microsoft's clock in high-end systems.

Smartphones

Let's look at another example: smartphones. Palm and Blackberry were the first big players in this market, and Windows Mobile came along after that. Since those early days, all three of these OS's have remained essentially the same, and that's now causing them to look very, very dated. The iPhone, and to a lesser degree, Google's Android, are eating their lunch.

Palm's situation had gotten so dire, in fact, that many predicted their demise. Out of this desperation, though, Palm launched the Pre, which (surprise) is based on a brand-new OS. This isn't a coincidence: Palm simply wouldn't have been able to get to the Pre by migrating PalmOs incrementally, taking care not to ruffle any feathers along the way.

Lessons Learned

These disruptive changes are risky. Again, it's not surprising that it took a near-collapse on Palm's part to force them to roll the big dice on the Pre. This is a bet-the-company move for Palm, and they couldn't find the stones to make this move until they had little to lose by failing. This is not to say that I blame them; on the contrary, it's really an acknowledgment that it's a truly bold move to see companies innovating like this when they're still on top.

So what's the lesson here?

Simple. When you make platform decisions, understand that you're going to be sticking with them for a while. Your designs and decisions have the potential to stick around and haunt you for a very long time. But when you do determine that it's time for a change, you need to be able to cut the chains and move on every once in a while.

It's never too late to learn. Microsoft is demonstrating that they've learned this lesson (to some extent) in Windows 7. They've just announced that they're going to include a virtualized, licensed copy of Windows XP so that users can run old software in that old OS. Not only will this make the customers happy (because the can keep their old apps), it also sets the stage for Microsoft to finally kick some of that old OS compatibility code to the curb. Good riddance.

What's the albatross around your neck? What's it going to take for you to finally get rid of it?

Related articles by Zemanta

• Microsoft's Long Slow Decline (daringfireball.net)
• Report: Windows XP's reign finally coming to an end (seattlepi.com)
• Switched On: The last smartphone OS (engadget.com)
• AdMob report finds Android lifting off, passing Windows (venturebeat.com)

I'm a few days into working with the Azure July CTP, using Steve Marx's excellent PDC presentation as a bit of a primer.  I'm following along with Steve's presentation, and it was working just fine for a while.  I had a working Azure app, using an MVC front-end, and I was reading and writing images as blobs from the local development-version storage pools.

Then, the next thing I knew, I was busted:

I shut down the Development Fabric, as instructed, and even restarted my machine, to no avail whatsoever.  I started Googling this error, and found a handful of other people who've seen this error, too.  I even found a bug logged on Microsoft's Connect site, but no solution has presented itself.  There's an event (3006: Parser error) logged every time I try to start the app, but that's the sum total of the clues I've got to go on with this one.

So far, I've tried tearing out all the stuff I've added to the project since it was last working (which didn't help at all), I've tried blowing away and recreating the storage pools (no joy), and I've tried creating a brand-new Azure project (which worked).  Thus, I'm forced to conclude that something caused this particular project to be irreparably hosed, but I've still got no idea what caused the problem.

This could really slow me down...

Related articles by Zemanta

• A Stick Figure Explains Microsoft Azure, and Other Cloud Video Gems (gigaom.com)
• Is Azure ready for production usage? (bloggingabout.net)
• Different ways to react to outages in the cloud: Google vs Microsoft vs Amazon (themindstorms.blogspot.com)

I'm doing some research on Azure (finally playing with the bits), and in the process, spending some time cruising Steve Marx's blog.  Steve presented some Azure stuff at PDC earlier this year, and there's some great stuff on his blog if you're working with Azure for the first time.  One of the things you'll learn if you watch his PDC stuff is that his blog is, itself, built on Azure and running in the cloud, so it should be a showcase for all of Azure's scalability claims.

Thus, it was with great surprise that I clicked a link and saw this Azure app apparently taking a dirt nap:

I refreshed a couple of times, to no avail, and finally tried going back to the home page, which worked fine.  I'm still not sure exactly what went wrong, but it would appear that the god-awful token that was used to track my navigation got lost in the cloud somewhere.

The lesson here?  For production apps, you're still going to need to build your Azure apps defensively, and make sure that customer-facing hiccups are handled in a user-friendly fashion.  As a user, I don't know (or care) if this error was an Azure failure or a failure of the app that's hosted on Azure.  This isn't a dreadful error when I'm browsing a blog, but it could have been if I'd been paying bills or making an online purchase.

I just found a site called highscalability.com via feedly.  There's some great stuff in here, including the article I read first: Stack Overflow Architecture.  If you're building big apps or apps that you hope will be big someday, you're going to want to add this blog to your reader.

Related articles by Zemanta

• Learning from StackOverflow.com (redditech.blogspot.com)
• Google Reader Gets A Social Makeover (techie-buzz.com)
• What should a developer know before building a public web site? - Stack Overflow (redditech.wordpress.com)

Back in February, amidst the news about Microsoft's new Azure platform, I asked why the concept of Private Clouds seemed to be either dismissed or ignored as a viable Enterprise strategy (see also "PDC Reactions" and "Could Azure be self-hosted?").

Yesterday, I learned that there's hope, after all.

I happened to be in the office for one of our internal MS development "user group" meetings, and we were lucky enough to have Brian Prince stop in to talk to us about Azure.  The talk was great - he demo'ed a super-simple sample app that really helped make some of the Azure concepts real, but one of the things that caught my attention was only mentioned in passing: Microsoft is bringing Azure technology to private data centers.

Point #1 -- boot from VHD.  This is a cool little novelty item in Windows 7, but it turns out that its origin is really the Azure team.  This is how they spin up instances for you, and it was a cool enough idea that the Windows team built it into Win 7.

Point #2 -- Yes, Microsoft is going to power private clouds.  Mark my words: this is going to be big.  In fact, why don't you leave yourself a reminder to come back here in about five years so I can say, "I told you so."  This is absolutely one of those technical announcements that's completely underwhelming at introduction because it's so disruptive that people don't know how to deal with it.

When you read about MS's Private Cloud products, watch for the bit about chargebacks.  You'll probably miss this the first time you read it.  Again, this line-item doesn't mean too much until you consider that this technology is coming from Azure.  You know -- Azure -- the platform where you can rent capacity and Microsoft sends you a bill at the end of the month.  How'd you like to be able to do that for your internal customers?  I thought so.

So what's an architect to do if this technology won't be fully appreciated for a number of years?

Simple.  Learn the basics of the technology and start architecting for the cloud even if your app and the cloud aren't quite ready for one another.  Specifically,

• Look at how cloud apps scale.  The way storage and processing scale in the cloud is different than what you're used to.  Figure out what that means, and design to be compatible with this.
• Revisit your storage assumptions.  Azure is going to support SQL Server, but it's clear that SQL Server isn't the 100% brain-dead automatic end-all-be-all storage choice that it once was.
• Get comfortable with messaging and queuing.  This is how cloud components are connected.
• Get comfortable with threads.  This should be on your list anyway, because of the rise of multi-core processors, but if you understand thread management, you'll be more comfortable with processing threads distributed across the cloud.
• Think about chargebacks.  If you're suddenly able to track processing and storage utilization with great ease and accuracy, what does that mean for your shared applications?  How would you split up costs for services that are shared across departments?

There are some really powerful concepts here that are just starting to emerge, and now is the time to start wrapping your brain around them.

What can your enterprise do with private clouds?

Related articles by Zemanta

• SQL Services is now SQL Azure (blogs.msdn.com)
• Exploring Scalability, Performance And Deployment (slideshare.net)
• Talking about Microsoft's Windows Azure with Amitabh Srivastava (cloudofdata.com)
• Microsoft preps massive cloud expansion (theregister.co.uk)

I love these dialog boxes:

How hard, exactly, would it be to figure out that a process that had been running at a rate of "x" had suddenly dropped to an entirely unreasonable speed -- so slow, for instance, that perhaps it had actually stopped, and thus, would very likely either fail or resume operating at a reasonable speed again?

Apparently, it's pretty difficult.

I recently read a review of a new Lotus (the car, not the spreadsheet), and the reviewer recalled the defining design tenant of Colin Chapman, who explained that his goal was always to "add lightness".

This isn't as straightforward as one might imagine in car design -- we don't easily give up all the conveniences we've come to expect over the years (radios, antilock brakes, windshields, etc.).  Similarly, government regulations insist that our cars meet certain safety standards.

These are certainly good things for us and our automobiles, but they've resulted in a substantial bloating of our automobiles over the years.  It's simply easier to make a car safer by adding more steel, for instance.  When the performance of the car suffers, it's far easier to bore out the motor or add a couple more cylinders than it is to find and trim excess weight.

A typical sports car has a power-to-weight ratio of 1:10 or better (or 10 lbs. per horsepower).  This means that if you want to boost the performance of your car by either adding power or reducing weight, this ratio suggests that adding 10hp would be roughly equivalent to dropping 100lbs.  Which do you think is easier?  How about if we make it 50hp or 500lbs?  There's simply no way you can remove 500lbs from a modern car without making some compromises, and/or incurring extra costs by employing exotic materials.

So why bother "adding lightness"?  Why not just bulk up with a bigger motor?  Part of the answer is the feedback loop you start.  A bigger motor will itself weigh more, so part of its additional power is offset by its own weight.  You'll need bigger brakes to slow this extra weight down.  Bigger brakes will call for larger wheels to clear the discs.  Maybe a bulkier frame to accommodate the power.  Beefier suspension pieces to deal with the extra weight.  Pretty soon you've eaten up a fair bit of the power you just added, and the weight of your car is up dramatically.

The rest of the answer, though, can only be appreciated by driving a light car.  Rather than rely on huge tires to grip the road and a huge engine to move you, a light sports car is quick because it's light.  A Lotus is more nimble, tossable, and agile than its competitors in large part because it doesn't carry as much mass.  There's less inertia to overcome when changing directions, and the driver feels much more connected to the road.

There's got to be a software lesson here, doesn't there?

Indeed, there is.  In our world, we add lightness by adding simplicity.  Just as we don't want to live without antilock brakes, nobody really wants to go back to running DOS or green-screen applications, but where are the places where we've accrued bulk unintentionally?

Do you remember your reaction the first time you saw Ruby-On-Rails, or maybe even MS Access?  A simple approach to software can make us question how we ended up with all the bulk we see in many of our applications.  How many lines of code exist simply because "that's the way we always do it"?  If you start simpler, can you do without some of the layers we take for granted?

How do you add lightness to your software?