(For more resources related to this topic, see here.)

Understanding the SproutCore approach

In the strictly technical sense, I would describe SproutCore as an open source web application development framework. As you are likely a technical person interested in web application development, this should be reassuring. And if you are interested in developing web applications, you must also already know how difficult it is to keep track of the vast number of libraries and frameworks to choose from. While it would be nice if we could say that there was one true way, and even nicer if I could say that the one true way was SproutCore; this is not the case and never will be the case. Competing ideas will always exist, especially in this area because the future of software is largely JavaScript and the web.

So where does SproutCore fit ideologically within this large and growing group? To best describe it, I would ask you to picture a spectrum of all the libraries and frameworks one can use to build a web application. Towards one end are the small single-feature libraries that provide useful helper functions for use in dynamic websites.

As we move across, you’ll see that the libraries grow and become combined into frameworks of libraries that provide larger functions, some of which start to bridge the gap between what we may call a website and what we may call a web app. Finally, at the other end of the spectrum you’ll find the full application development frameworks. These are the frameworks dedicated to writing software for the web and as you may have guessed, this is where you would find SproutCore along with very few others.

First, let me take a moment to argue the position of full application development frameworks such as SproutCore. In my experience, in order to develop web software that truly rivals the native software, you need more than just a collection of parts, and you need a cohesive set of tools with strong fundamentals. I’ve actually toyed with calling SproutCore something more akin to a platform, rather than a framework, because it is really more than just the framework code, it’s also the tools, the ideas, and the experience that come with it.

On the other side of the argument, there is the idea of picking small pieces and cobbling them together to form an application. While this is a seductive idea and makes great demos, this approach quickly runs out of steam when attempting to go beyond a simple project. The problem isn’t the technology, it’s the realities of software development: customization is the enemy of maintainability and growth. Without a native software like structure to build on, the developers must provide more and more glue code to keep it all together and writing architecturally sound code is extremely hard. Unfortunately, under deadlines this results in difficult to maintain codebases that don’t scale. In the end, the ability to execute and the ability to iterate are more important than the ability to start.

Fortunately, almost all of what you need in an application is common to all applications and so there is no need to reinvent the foundations in each project. It just needs to work and work exceptionally well so that we can free up time and resources to focus on attaining the next level in the user experience. This is the SproutCore approach.

SproutCore does not just include all the components you need to create a real application. It also includes thousands of hours of real world tested professional engineering experience on how to develop and deploy genre-changing web applications that are used by millions of people. This experience is baked into the heart of SproutCore and it’s completely free to use, which I hope you find as exciting a prospect as I do!

Knowing when SproutCore is the right choice

As you may have noticed, I use the word “software” occasionally and I will continue to do so, because I don’t want to make any false pretenses about what it is we are doing. SproutCore is about writing software for the web. If the term software feels too heavy or too involved to describe your project, then SproutCore may not be the best platform for you.

A good measure of whether SproutCore is a good candidate for your project or not, is to describe the goals of your project in normal language. For example, if we were to describe a typical SproutCore application, we would use terms such as:

• “rich user experience”
• “large scale”
• “extremely fast”
• “immediate feedback”
• “huge amounts of data”
• “fluid scrolling through gigantic lists”
• “works on multiple browsers, even IE7”
• “full screen”
• “pixel perfect design”
• “offline capable”
• “localized in multiple languages”
• and perhaps the most telling descriptor of them all, “like a native app”

If these terms match several of the goals for your own project, then we are definitely on the right path.

Let me talk about the other important factor to consider, possibly the most important factor to consider when deciding as a business on which technology to use: developer performance. It does not matter at all what features a framework has if the time it takes or the skill required to build real applications with it becomes unmanageable. I can tell you first hand that custom code written by a star developer quickly becomes useless in the hands of the next person and all software eventually ends up in someone else’s hands.

However, SproutCore is built using the same web technology (HTML, JavaScript and CSS) that millions are already familiar with. This provides a simple entry point for a lot of current web developers to start from. But more importantly, SproutCore was built around the software concepts that native desktop and mobile developers have used for years, but that have barely existed in the web. These concepts include:

• Class-like inheritance, encapsulation, and polymorphism
• Model-View-Controller (MVC) structure
• Statecharts
• Key-value coding, binding, and observing
• Computed properties
• Query-able data stores
• Centralized event handling
• Responder chains
• Run loops

While there is also a full UI library and many conveniences, the application of software development principles onto web technology is what makes SproutCore so great.

When your web app becomes successful and grows exponentially, and I hope it does, then you will be thankful to have SproutCore at its root. As I often heard Charles Jolley , the creator of SproutCore, say:

“SproutCore is the technology you bet the company on.”