Ryan Bennett

Atlanta Agile Software Development Consultant, Mobile and Web Software Architect

Why I Moved Away From Microsoft ASP.NET

Back in the late 90s, I was a hardcore Microsoft devotee and web developer that enjoyed JavaScript but wanted to get away from coding in Perl. Seeing a large amount of demand for Microsoft development skills, I started developing on the Microsoft platform using Visual Basic 5 and “classic” ASP in 1997. I moved to .NET after the release of .NET 1.0 Beta and kept on truckin’.

Fast forward about 11 years later, and I started making the move away from Microsoft. I bought a Mac, worked on a Django project or two, and eventually left Microsoft’s ASP.NET platform and Django for the world of Node.js and full time JavaScript. After a (very very) brief stint working at Microsoft, I abandoned Microsoft technologies all together. I no longer actively work on pure .NET projects and turn down projects based on ASP.NET Web Forms as a general rule.

A lot of the reason for this move came from my time in corporate management, serving as a technology director during a down IT market. Many others came from exploring emerging platforms in the realm of web software development.

TL;DR: Microsoft’s ASP.NET is too restrictive and costs too much. Microsoft’s target audience builds products that are generally poorly written and lag 4-8 years behind the current platform version. Other open platforms can be used with little to no cost and lower overall cost of ownership.

Microsoft licensing costs are insane

Microsoft’s licensing structure and costs and are absolutely insane. I can build, deploy, and market test a product or feature using platforms such as Java, Rails, Django, or Node.js for a small fraction of what Microsoft charges, without the licensing headache. Plus, I’m not tied to only one operating system.

(Quick aside: yes, Mono is cool and cross-platform. It also lags behind the current version of the .NET Framework and represents the smallest of fractions of actual production .NET use.)

The vast majority of .NET projects involve working with giant, monolithic, boring, poorly written, legacy “enterprise” products. These products always seem to be 4-8 years old and 2-3 major platform releases behind the current .NET framework, in part because of the sheer complexity of modernizing. Coupled with the insane licensing, capital, and labor costs to develop a product using Microsoft’s platform, these products are rarely modernized because the business has barely broken even on the initial project investment. Investing in new feature development always beats investing in the cost to upgrade to the latest .NET version in most “enterprise” organizations.

Yes, BizSpark is a great program for giving free Microsoft stuff to startups. It’s like a drug dealer giving free samples to get you hooked on their expensive and now compulsory wares.

No focus on the user experience

When Microsoft first released ASP.NET, they wanted it to feel as familiar as possible to Visual Basic 6 developers transitioning into the world of web development. They introduced “Web Forms,” a concept where developers dragged and dropped web controls on to WYSIWYG-ish documents and wrote “code-behind” logic to create features. Developers coming from ASP and CGI development had to completely relearn how to develop for the web, as Web Forms hid so much of the mechanics of the web behind a giant form tag and a humungous hidden __VIEWSTATE field and on each page.

Over time, the back end architecture of these applications became better, while the front end user interface suffered horribly. ASP.NET developers were pleased with whatever generated HTML was sent to their Internet Explorer session. Microsoft gave half hearted fixes such as “skins” and the spewer of horribly generated JavaScript that was ASP.NET AJAX.

I would estimate that 85-90% of the senior ASP.NET candidates I interviewed could tell me what nondeterministic finalization was, but couldn’t tell me how to dynamically position a DOM element using only JavaScript and CSS.

ASP.NET platform features are always behind other platforms

Sure, Microsoft introduced ASP.NET MVC in an attempt to move away from the Web Forms problem. Of course, ASP.NET MVC borrowed heavily from Rails, Django and Java frameworks like Spring, which were around for years before.

Adoption of ASP.NET MVC was terrible, in part because of the expense involved in undertaking any Microsoft upgrade. ASP.NET Web Forms developers had a difficult time understanding why MVC was a good thing, learning when to use MVC instead of Web Forms, or finding time to learn a new method for web application development.

Microsoft has tried to make MVC more attractive by replacing the original and confusing “Web Forms View Engine” with the “Razor” view engine, as well as a host of other moves. ASP.NET Web Forms, however, still rules the ecosystem.


I moved away from .NET primarily so I could use free and open platforms to rapidly develop, deploy, and market test products for myself and my clients. Modern open web platforms are easy to acquire, easy to configure, and easy to learn. They are on the leading edge of the web development industry and provide everything needed to create engaging user experiences on top of scalable and performant architectures. The largest web applications on the planet – Google, Facebook, Twitter – use free, open, non-Microsoft technology. And I do too.

Sencha Touch 2 Quirks: Floating Panels

Floating panels (like the one below) are a great way to present helpful content, such as a form or help text, within the context of a parent user interface screen. Unfortunately, the Sencha Touch documentation fails once again at clearly explaining a useful framework feature. In the Ext.Panel documentation, they show some crazy way to use the Ext.Panel.showBy method, which is extremely unhelpful and dosen’t show how to use it in an MVC context. Further, the Overlays sample application is obfuscated and breaks all MVC convention and most general Sencha Touch conventions. Here’s a brief tutorial on how to actually use this in an MVC application.

Floating Panels are simply Ext.Panel controls that are hidden from the main Viewport. These panels are displayed much like an Ext.Msg.alert call, with the ability to customize them at a finer level of detail.

The panel itself is fairly easy to create:

Ext.define('App.view.FloatingPanelView', {
  extend: 'Ext.Panel',
  alias: 'widget.floatingPanel',

  config: {
      id: 'floatingPanel',
      html: '<p>Here is some content.</p>',
      styleHtmlContent: true,
      hidden: true,
      height: '200px',
      width: '200px',
      scrollable: 'vertical'

The modal and hideOnMaskTap configs provides the user with a visual indication that they can tap anywhere on the screen away from the panel to close the panel. The height and width configs take any CSS compatible pixel or percentage value. You can use maxHeight and maxWidth to loosely define hiehgt and width if you are not using the optional scrollable config.

A tricky piece is the scrollable config. It defaults to false and requires strings such as ‘vertical’ or ‘horizontal’ do indicate the direction of scrolling allowed. If you not explicitly define a height and width config, however, your panel will be displayed as a jumbled mess. This behavior is not officially documented at all, however this Sencha thread discusses the issue.

To show the panel on the tap of a button, you use it in your controller (or listener) like so:

Ext.define('App.controller.PanelDemoController', {
    extend: 'Ext.app.Controller',

    config: {

        control: {
            myButton: {
                tap: 'myButton_tap'

        refs: {
            myButton: '#myButton',
            floatingPanel: '#floatingPanel'


    myButton_tap: function(button) {
        this.getFloatingPanel().showBy(button, 'br-tc?');

The Ext.Panel.showBy method automatically builds a frame around your panel and an arrow pointing at the button passed in the first argument. The second argument is a cryptic string:

  • The first two characters describe the arrow’s placement relative to the panel, in this example “bottom right”
  • The two characters after the dash describe the arrow’s placement relative to the item tapped, in this example “top center”
  • The final ? is optonal and forces the panel to be visible within the bounds of the Viewport. Omit this at your own risk! The decoder ring for these strings are located in the Ext.Panel.showBy documentation.

I know this dosen’t describe everything floating panel related, such as using the Exp.Panel.show method or quirks using forms inside of a floating panel. Perhaps I will get to this down the road!

Sencha Touch 2 Quirks: Controller Refs, ComponentQuery, and Using Id vs itemId

The Sencha Touch 2 documentation is absolutely brutal. I am going to keep track of the quirks I resolve on the blog to hopefully help myself and others.

In this edition: A fun, poorly documented quirk involving controller refs and ComponentQuery.

The Ext.Component documentation encourages the use of the itemId config over the id config due to the global nature of using id. According to the Ext.ComponentQuery documentation,  a query using a leading “#” in the selector string is supposed to match the id or itemId defined within the config of an Ext.Component you would like to reference. Except that is not the case.

Buried in the somewhat un-friendly dungeon known as the Sencha Touch 2 forums, the resolution to a bug report states that Ext.ComponentQuery can only resolve a component using itemId if a parent component is referenced in the query!

So let’s say you have:

Ext.create('Ext.Panel', {
   itemId: &quot;parentPanel&quot;,
   items: {
      itemId: &quot;childPanel&quot;,
      html: 'Child Panel',

Ext.ComponentQuery.query('#childPanel') will not work, but Ext.ComponentQuery.query('panel #childPanel') and Ext.ComponentQuery.query('#parentPanel #childPanel') will work.

Controller refs are essentially an alias for an Ext.ComponentQuery selector string used within a controller, so this issue directly applies to Ext.Controller. This particularly comes into play when you try to create a ref by itemId to a view separated into a dedicated file, since you have to switch to the id config or include a reference to the main view component in your app.js to get a reference.

Overcoming IT Skills Gaps

Over the past five years, information technology has taken a huge leap. Mobile development, HTML5, the rise of dynamic software languages, agile and lean development methodology, cloud computing, and infrastructure virtualization are just a few of the areas that have seen massive growth. In many CIO / IT Executive circles, many feel that a skill revolution is around the corner. I believe they are late to the party; the revolution has occurred around them. The majority of the industry is playing catch up.

During the “Great Recession,” many IT departments slashed budgets, investing only the minimum to keep legacy systems on life support. IT professionals were asked to work longer hours maintaining systems based on technologies that are now in a range of 5 to 20 years old. Time and funds that were used for staff training and certification dried up, leaving IT professionals to fend for themselves. A gap has formed where many IT pros have mastered the skills of the 2000’s but have had zero exposure to the landscape of the 2010’s.

Today, the IT sector has recovered from the recession and hiring is at an all time high. A colleague of mine who is a partner in an IT staffing business explained to me that here in Atlanta, there are about eight open positions paying over $100,000 annually for every one senior-level Microsoft .NET developer. If you dig deeper, what is truly happening is that companies are now trying to accelerate to today’s technology, and even senior level IT professionals are not meeting the job requirements they desire.

Interestingly, the IT professionals (including yours truly) that consider themselves to be free agent “mercenaries” are now the most qualified. What traits do these technology soldiers of fortune possess that all IT professionals should have in this new world?

  • An understanding that there is no such thing as “permanent employment.” Take some time to read Pamela Slim’s Escape from Cubicle Nation for numerous illustrations of this.
  • Recognizing that IT outsourcing is the future of the industry. Information Technology departments are shrinking, even with the available job openings. Companies are outsourcing everything IT related. Cloud vendors make it possible to have minimal hardware infrastructure. Offshore development firms are as affordable as ever. IT operations can easily be handed over to vendors. IT consultants are hired to shore up major skill gaps. Position yourself as a vendor, even if you take a “permanent” position.
  • Valuing communication, business fundamentals, leadership, strategy, and customer service over technical prowess. It’s easy to find people who can configure a router, create a virtual machine, back up a database or code in any language you want. I build my teams around great people, not just great technical skills. Spend as much time learning project management, business analysis, business fundamentals, leadership, and customer service as you do technical skills.
  • Taking full responsibility for your own career development. Understand that companies are scared to provide training unless there is an immediate benefit to them. Purchase your own books and training courses. Free resources – from books, to videos, to even free cloud infrastructure – are abundant. Understand that in today’s IT, you must sacrifice your free time at some point – choose to spend it learning marketable skills and concepts.
  • Generalization over specialization. Finding a niche in IT is a great way to work yourself out of a job. Just ask ColdFusion, Adobe Flex, or Silverlight developers, all whom have seen their technologies of choice pulled out from under them like an old rug. Diversification is as important in your skill set as it is in your 401(k).
  • Following emerging technologies and methodologies very closely. We followed the emergence of Model-View-Controller frameworks, dynamically-typed languages, and Scrum seven years ago. Today, these are all mainstream concepts. Start learning about tomorrow’s technologies today.

The Essential Reading List for Every Software Professional

There was once a time where the only books I would read would be 500+ page technical books. Books with titles like “Professional Programming in ASP.NET MVC 3 with Entity Framework.” These days, however, I have become quite a fan of many different leadership, time management, marketing, and business books.

Recently I was asked what books I would recommend to someone as absolutely essential reading. Without further ado, I present my Essential Reading List:

How To Win Friends and Influence People by Dale Carnegie: Yes, this book is very old, and the stories Carnegie tells feel very antiquated. Regardless, this book is essential for understanding how to truly engage people you encounter in any situation in your life.

Getting Things Done by David Allen: This book, commonly referred to on the interwebs as “GTD,” was literally life changing for me. Allen explains that all the junk in your head relating to the things you need to do on a daily basis distracts you from actually accomplishing anything at all. The GTD system is absolutely brilliant, showing you how to best organize all of the “action items” of your life and actually accomplish them without fear of forgetting something somewhere down the line. If you are “gifted” with any degree of  ADHD, as I am, this book alone will help you dramatically.

Personally, I combine GTD with The Secret Weapon framework for Evernote and the Pomodoro Technique to turbo charge getting things done.

The 4-Hour Workweek by Tim Ferriss: Want the ability to work for your your self from anywhere in the world with as little work output as possible at any time? It’s a little far-fetched for those of us who choose to have kids and pets, but the lessons learned in this book are fantastic. It’s a great blueprint for maximizing your productivity through minimizing distractions from meetings, email, and co-workers while setting up your own business.

Good to Great by Jim Collins: A classic business book examining the real-life qualities of leadership that build companies that can stand the test of time. Collins uses real empirical data mixed with classic metaphors such as the Hedgehog Principle and the Flywheel Principle to demonstrate what it takes to be a true leader forging a great company.

Be Our Guest: Perfecting the Art of Customer Service from The Disney Institute: This is a book I urge teams that I lead to read. It is a quick, easy read that highlights the customer guest service approach at Disney Parks. Be Our Guest explains what guest service is, the business reasons behind it, and the principles to execute on providing a fantastic experience. IT professionals commonly are thought of as back-office workers ”cast members,“ when the truth is that we all have customers even inside of our own organizations that we must provide great service to.

Optional (though still essential) Reading:

Rework by Jason Fried and David Heinemeier Hansson: This book is a recent one for me, and I am tempted to move it to the mandatory essential list. The authors are the founders of 37Signals, creators of Basecamp, and (for DHH) the inventor of Ruby on Rails. It is a collection of essays that underscore very important themes. Limit office distractions, emphasize less over more, simplify instead of adding more features, realize that planning is just guessing, get started now instead of later, and learn from your successes instead of your mistakes.

The 7 Habits of Highly Effective People by Stephen Covey: A classic that I recommend reading immediately after How to Win Friends and Influence People.

EntreLeadership by Dave Ramsey: A great primer for those running or starting their own business. Ramsey inserts his deep spiritual beliefs into the book regularly, which influences his advice on hiring and human resources issues in a manner that I disagree with. Overall, I found the business content of the book to be excellent.

Clean Code: A Handbook of Agile Software Craftsmanship by Robert C. Martin: If you write code, you must read this book. You must understand this book. You should live this book.

Simply Moving Desktop Art

I was inspired by simpledesktops.com and decided to create a simple desktop background of my own. I’m not a Photoshop expert by any means, however the simple style suits me well. My MacBook Air looks quite nice with Monorail Orange.

Click the image for the full sized view. Feel free to download and use on your own system!

Cross Platform Application Development in a Mobile World

The team at AtomicGarden has been working on requirements for a number of great upcoming applications for mobile and web-enabled devices. One of the requirements that has been the most difficult to define is the platforms the applications should support. Our combined team skill set gives us many options: HTML5, Microsoft Silverlight, Adobe Flash / Flex / AIR, Java, and Apple iOS, to name a few. The question then becomes this: do you write one cross-platform app for multiple screens, or write one native app for screen?

Option one is to simply write a killer HTML5 web app. One app to rule them all! (Ok, probably not.) My opinion on web apps is that with the introduction of app stores and marketplaces on mobile devices, a web app limits you to a desktop-only audience. For example, Mobile Safari on iPhone is a very deep HTML5 web app platform. Unfortunately, iPhone users probably won’t use a web app; on iPhone you can find, purchase, install, and begin using a native app from the Apple App Store in a matter of minutes.

Option two is to create an app using one of many cross-platform libraries. Adobe AIR, with its ability to package and deploy a single Flash or HTML application to web platforms, desktop platforms, Android devices, Blackberry Tablet OS devices, and iOS devices is a compelling option.  For example, Christian Cantrell demonstrates a cross-platform app using Adobe AIR:

Other options, such as the open source PhoneGap library, Appcelerator Titanium, or Ansca Mobile Corona, offer you various degrees of cross-platform flexibility as well. Write once, tweak a little for each platform, and deploy, right? Unfortunately, Flash is notoriously power hungry and crash prone, as well as immature on mobile platforms. They also offer tradeoffs such as varying degrees of documentation completeness, slower performance compared to native apps, and inconsistent user experiences compared to native apps. No one library hits all platforms yet; for example, none of these platforms have documented support for Windows Phone 7 today. With the exception of PhoneGap, all of these libraries incur substantial licensing costs above and beyond just getting your app into an app store. Finally, based on what Steve Jobs had for breakfast that day, you never really know if your cross-platform library-based app will make it into the App Store on any given day.

That leads us to option three: go native. Native apps give your users the user experience they expect on their device, with speed and responsiveness to match. With native apps, you won’t be denied from an app store because you didn’t use the language du-jour. The downsides here are obvious: for each platform you support, you must port and maintain code for each one. You need a team that can write in multiple languages, some of which may seem completely foreign. (Objective-C, anyone?) You will need a Mac if you have any intention of developing an iOS app.

At the end of the day, perhaps the best strategy is to market test individual products on a single platform and compare the traction they receive. If an app takes off, begin porting that app to other platforms.

What are your thoughts on cross-platform mobile development strategies?

Reflections on “the Mythical Man-Month”

After recently reading Frederick P. Brooks, Jr.’s essay “The Mythical Man-Month,” I came away with the belief that it should be required reading for all individuals involved with software development projects. CEOs, CIOs, CTOs, project managers, product managers, business analysts, development managers, software architects, software engineers and developers alike will all benefit from the wisdom contained within.

The essay is famous for introducing to the software industry what is known as Brooks’s Law: “Adding manpower to a late software project makes it later.” Interestingly, I found many other great insights in the essay as well:

Nine women can’t make a baby in one month.

It’s an old cliché thrown around in countless meetings across the world, yet it seems so easily forgotten. If a software project is estimated to take 12 months to complete, it’s fairly common that one or more individuals with “skin in the game” will interpret that estimate as 12 man-months; putting 12 developers on the project will mean the project will be completed in one month.

The reality is that software development is serial in nature, and each task in a project often depends on one or more tasks to be completed first. The key is to identify these task dependencies and then determine which of these task “threads” will take the longest amount of time; i.e. determining the “critical path.” It is this critical path that will determine the minimum amount of time a project will take to complete, regardless of how many people you throw at it.

A cake will take the same amount of time to bake, regardless of how hungry your patrons are. Try to turn up the heat, and you will burn the cake.

True story: I once had a Marketing Vice President demand a project that was estimated to take one year with two developers be completed in four months with the same two developers. The reason? The sole woman performing telemarketing and customer service was due to give birth in five months and desired one month in between deployment and maternity leave to communicate with customers.

Much like hungry restaurant customers demanding that their uncooked food be delivered to their table, project stakeholders will often conjure up unrealistic deadlines for software to be delivered.

Development managers, who seem to be born optimistic, often commit to these arbitrary deadlines out of fear for their jobs, even when they know there is very little chance of meeting that commitment. Brooks notes that this seems to occur in software engineering much more often than in other engineering disciplines.

How do you defend your project estimates? It is very difficult to lean on metrics such as tasks completed per period of time (known as “velocity” in agile circles), estimating standards such as COCOMO II, techniques such as “planning poker,” or rules of thumb such as adding 25% to your estimates for QA testing. This is because software requirements are living documents, and it is difficult to predict project risks. There’s only so much you can do to save the project when three months of work is added mid-stream or developers quit. Brooks proposes that development managers simply must “stiffen their backbones,” as these estimates are always more accurate than arbitrarily mandated deadlines.  Alternatively, I propose providing (and sticking to) a ranged estimate based off of factors including perceived project risk and perceived percentage of requirements accuracy.

Coding isn’t everything.

It is easy to fall into the trap that the level of effort required to complete a task is limited to the programming of the software alone. For every hour of implementation coding, I estimate two hours of design.

According to Brooks, the most misestimated portion of a software project estimate is testing.  Brooks estimates that for each hour of coding, eight hours can be estimated for unit testing, integration testing, regression testing, debugging, and repair of defects. I would suggest adding even more time if your developers are creating automated unit tests or performing Test-Driven Development.

Have you read this essay? If so, what have you taken away from it?

Buy the book here: The Mythical Man-Month: Essays on Software Engineering, Anniversary Edition (2nd Edition)

Welcome to the Blog!

My name is Ryan Bennett, and I am a web software development manager, architect, and developer based in metro Atlanta. Often, as I go through my day, I always keep finding things that have me thinking to myself:

“Yanno, this would be a great topic for a blog post!”

So, here we are! A little more about me:

  • I have a beautiful daughter, Alex, and an awesome son, Zach.
  • I first started development using BASIC on a Commodore VIC-20 my parents gave me when I was 9 years old.
  • My first exposure to web development came in 1996 as an undergrad student at the University of Florida.
  • As a web developer and architect, I have primarily used Microsoft’s web development tool set, specifically Microsoft ASP.NET.
  • As a software development executive, I have led teams large and small through a number of web projects equally varying in size.
  • I highly enjoy the business of the Web, having previously started two technology companies (Progressive Computer Research in Lake Worth, Florida, and AtomicGarden in Atlanta, Georgia).
  • I love the Scrum Development Methodology and I’m a Certified Scrum Master (CSM).
  • I’m kind of obsessed with the Walt Disney Company Parks and Resorts division. I take great inspiration from what they do and the success they have had. I look for ways to integrate that inspiration into what I do.
  • Syd and I write a Walt Disney World blog, Dis On A Dime.
  • I love anything with an engine. Motorcycles, cars, boats, airplanes, lawn mowers, you name it.
  • As a hobby (and a test bed to try out new technologies), I run AtlantaBiker.com.

You can learn more about my professional experience, including an overview of my resume, by visiting my LinkedIn page.

I hope you enjoy the blog and get as much out of reading it as I get out of creating it.