Nodally recently attended the Cloud 2020 Summit at Switch SuperNAP in Las Vegas. The facilities were state-of-the-art and it proves a new level of thinking about efficiency and performance. We had the pleasure to meet many incredibly smart people who are the thought leaders and forward thinkers in the cloud space.
We are thinking about the cloud in a different way as well. But our focus is not limited to data centers or hardware. We are thinking differently about software. We are thinking about applications in a different light. We are thinking about the “Un-App“.
First of all, we have to admit that explaining an Un-App to people is not a simple task. Not because the Un-App is a hard concept to grasp, but because people are so fixed on a single (and current) concept of what constitutes an application.
What do you think about when someone says the word “application”? That really depends on your experience and perspective. If you are a user of applications, then you might think spreadsheets or word processing or some such. If you are a programmer, you might think more in terms of the code used to create an application. In each of these cases, you almost always think of an application as a single running program that consists of many features.
When we think of an Un-App, we don’t think in terms of code or single programs. We think of data. Not just data in a database, but live, free-flowing data that goes wherever it is needed. We think of events that are context + data. We think of processing that can act on those events to augment, make changes to, subtract from that data, route it, quantify it, aggregate it or split it up, so on.
The root problem we are trying to solve is one that had been around since the beginning of software. That is the monolithic nature of software. The industry has tackled the problem by thinking up better ways to code. To get more re-use and to find ways to make code easier to change and to debug. We have OOP and component-based design and a multitude of patterns and practices that have, each in their own way, contributed to better software. We have tried new techniques to manage the development of software which has given us Agile and the likes. But no one has yet to re-think the basics of what an App is.
Unfortunately, there really is no way to completely escape the monolithic nature of software. Some would argue that we have code libraries and objects that we can re-use. Yes, but you still have to glue them together to make use of them, which creates dependencies between code. And the glue code can get heavy and do not contribute to any functionality. Let’s not forget that there are many techniques to abstract things out in the name of reuse and agility. But it’s still all done at the code level. We need to think bigger, and smaller, at the same time. What do we mean by that? We will expand on these ideas in part 2 of the blog series.