Summary: Technology is evolving at breakneck speed. No one knows what the development landscape will look like in 5 or 10 years. How can you create enterprise applications that stand the test of time…when you don’t know what lies ahead? This article lists 7 tips to help you create applications that last.
What’s the next big tech trend? How will development standards evolve? What will the web look like in 10 years?
That’s the enterprise application development problem in a nutshell. No one knows the future, yet businesses expect future-proof applications. After all, no business wants to (or can afford to) recreate their applications every few years.
So, the question is: How can you create business applications that stand the test of time? How can you create applications that will still be in use 20 years down the road?
It starts with an underlying principle: Build for change. An application will never survive even a few years if left untouched. To stand the test of time, your application must evolve. It must adapt to meet changing business needs and trends.
How can you do that? Creating future-proof applications is a passion of ours, and today, I’d like to share some tips to help you do the same. Here are 7 rules you must follow to create applications that adapt to change:
1. Focus on your data
Do you remember what caused the Y2K problem? It was the practice of abbreviating a four-digit year to two digits in the database. This led to software that couldn’t tell the difference between the year 1900 and 2000.
In other words, it was a data problem. Developers designed their database structure assuming the applications wouldn’t last until 2000. This is always a mistake.
A clean, well-planned data structure is the first step in building future-proof applications. Create your data schemes with the assumption that it will last for 20 years (or even longer). Just think–if everyone thought like that, the Y2K problem would’ve never existed.
“First and foremost, when building your web application, your focus should be on the data,” says Jitesh Keswani, Co-Founder of e-Intelligence. “Platforms may change, newer technologies may be introduced, but if your app has a strong future-proof relevant data, then users will adapt themselves automatically.”
2. Don’t build for a single platform
What happens when you build applications for a specific technology, platform, framework, database, etc…? You’re tied to that technology. Your application’s success depends (in part) on outside factors.
What if the technology becomes obsolete? What if the platform vendor stops supporting their software? What if the framework evolves in a different direction? I’ve seen it happen time and time again. A business locks themselves into a single platform, and then struggles to adapt once it changes or becomes obsolete.
Guess what? It’s happening all over again with mobile. Rather than building for the web (a future-proof platform), some businesses are building platform-specific mobile apps. Will these platforms exist in a few years? Who knows?
“The current trend is to build device specific apps for the iPad, Android devices, etc,” says Kevin Baker, CTO of PageProdigy.com. “However, these apps cost a lot of money to maintain across all devices and platforms. Instead, building for HTML 5 and eventually HTML 6, an application can span across all devices. Since technology moves so fast, this method insures that all upgrades and improvements happen in one central place – maximizing resources and increasing the life span of the application.”
3. Separate your architecture
“To future-proof your app, you’d better have your application architecture well thought out,” says Dennis Kayser, CEO of Forecast.it. “It’s probably THE most important thing to do right, unless you want to risk refactoring a large portion of your codebase. Hint: You don’t want to spend money refactoring many thousands of lines of code. It’s expensive and sucks! No matter the technology you choose, the overall system needs to be well architected. A good architecture makes it simple to change parts of the code for new tech, new features, to run faster or migrate to a new platform. It also makes the application easier and cheaper to maintain. The goal of a proper architecture is that it enables business strategy today AND tomorrow.”
So, how do you create well-architected applications? We’re a huge proponent of n-Tier architecture, which separates your application into layers. While you can learn more about n-Tier architecture in this video, here’s the main point: It lets you maintain and enhance each application layer separately.
Why is that so important? Here’s a great example: Suppose you need to make your applications responsive for use on mobile devices. n-Tier architecture lets you replace the presentation layer, without altering the other layers.
“The key to building future-proof web applications is to build them in a modular way using proven open source technologies,” says Reggie Cole, Software Engineer at Broadleaf Commerce. “Proven open source technologies evolve and improve over time to solve problems as they come along and if you use them in a modular way, you can simply switch a part of your application to use another technology that is more suited to solve a new problem rather than having to remake your entire application.”
4. Stick to the standards
Imagine if everyone designed applications using whatever standards they personally deem best. Now imagine you were suddenly responsible for maintaining applications built by others using no clear standards.
Sounds like a nightmare, right?
This highlights the importance of web standards. Web standards are the formal, non-proprietary standards that define web development best practices. In short, they give developers a guide so every developer isn’t just making up their own “best practices.”
Standards aren’t always exciting. But, they leave you with a solid foundation on which to grow.
5. Use proven technologyDevelopers love using the “latest and greatest” technology. There’s nothing wrong with that. Experimenting with new technology drives advancement.
Just don’t opt for unproven, new technology when building business applications.
Why? You run the risk of choosing a technology that might never catch on. Opting for proven technology in your development projects promotes stability, security, and maintainability–and the overall success of your applications.
“Enterprises are notoriously weary of new technology so if you’re building enterprise apps think twice before you use “alien” technology,” says Kayser. “We all remember when Twitter moved from Ruby to Java because they had scalability issues. It’s a bit of a controversy, especially in the startup world where everyone is addicted to running the newest things. Enterprises like things to be predictable and with few risks, so they don’t end up supporting a system built on the next great thing, because what if it turns out not to be the next great thing? Then they’ll either have to redo the solution or end up paying huge amounts of money for a specialist to support them. Not a good situation.”
6. Listen to your users
If your application will stand the test of time, it must evolve. But, how do you know which features to add? How do you know which direction to take your application? As explained below, it all starts with your users. If you stay in close contact with your users, they will give you more ideas than you’ll ever have time to implement.
“Listen to your users,” says Harry E. Keller, PhD, President and Founder, Smart Science Education Inc. “You may have the same product in 20 years, but it will have evolved if it has survived.”
7. Do it right the first time
As mentioned above, your application will evolve. You will make changes and add new features. How you make these changes is of critical importance.
What do I mean by that? Sometimes, you’ll need a new feature added to your application quickly. Or, your application might need a quick fix. It’s tempting to just throw a bandaid on the problem. Cobble together some patchwork fix and throw it on the application. Over time, those “quick fixes” become an unmanageable mess.
There are two key principles to long-term application maintenance. First, fix problems the right way. Sure, this will take longer. But, it will save weeks of future headaches. Second, as explained below, document everything. Don’t assume you (or anyone else) can figure out what was changed.
“Another important aspect is to document everything, even the minutest detail,” says Keswani. “Over the span of two decades, you may not have the same staff that coded your app originally. A wiki like documentation system that can be tied to your data backup and bug tracking will help overall all such institutional shortcomings.”
So, what do you think? Is there anything you would add to this list? If so, please share your thoughts in the comments.