The underlying technologies that are enabling more complex adaptive systems are all in some way trying to break from today’s software and computing paradigms. However, the software development ecosystem is a confused array of tools and platforms. Designers and developers expect evolving software development tools to be functional, ubiquitous and easy-to-use. Within this construct, however, the first two expectations run counter to the third. In order to achieve all three, a new approach is required – a common means of developing and managing code that can orchestrate new development across families of interrelated hardware and diverse computing domains.
CROSSING THE CHASM
For decades we’ve been hearing that we’ll eventually cross a chasm and computers will finally form-fit themselves to human beings, rather than humans form-fitting to computers. And yet, more than forty years after Xerox PARC, we still haven’t made computing invisible. We live in a world of “apps” (a concept the PARC scientists opposed, incidentally) created by a priestly caste of programmers writing obscure code illegible to ordinary civilians. If you want a tiny app for your business, you have to hire an “app developer.” It’s something like insisting that people get an agricultural degree to plant a vegetable garden.
Software developers are the trained “specialists” who have created so much of the world we now live in. However, the tools application designers and developers work with today are still a relatively byzantine hodgepodge that are not well integrated, do not always support multi-user collaboration, are often not cloud native, and on and on. The front-end application design process still requires many separate tools and steps to just produce a design. Once the design is complete it still requires expensive developer resources to be converted into code.
Software development and applications drive companies’ innovation capabilities, increasingly determine the economics of their business, and influence their operating models and ability to grow. New generations of software are rapidly emerging driven by multiple hardware, software and architectural innovations. Software architecture is quickly becoming the foundation of every technology-driven organization; not just hardware and software companies but also any organization that is building digital capabilities.
The Number of Lines of Code Required is Growing
The impacts of these technological advances are twofold: On the one hand, new software technologies are enabling many new business and consumer-focused applications including artificial intelligence (AI), robotics, Internet of Things (IoT) solutions as well as augmented reality (AR) and virtual reality (VR). On the other hand, they have greatly increased the complexity of software development up and down the technology stack.
DRIVERS OF CHANGE – PERSPECTIVE and CONTEXT
Today, relatively few companies understand the necessity of re-thinking how their applications will be developed, consumed and managed. Even the latest platforms, cloud-native solutions, edge and IoT device development platforms have shortcomings. They tackle only bits and pieces of the problem, but do not address the overarching complexities of software development, tooling, testing, security and monitoring.
Very few people are thinking about how to address the complexities of software development on that level. Current software and IT technologists are operating with outdated models that were conceived in the mainframe and client-server eras and cannot serve today’s onslaught of new innovations.
For the last ten years or so, the evolution of digital systems has been largely comprised of moving data and workloads from physical hardware to virtual platforms. Developers have moved the data center to the cloud and businesses have transitioned from managing their own computing and network assets to “everything as a service.” We have transformed diverse processes from human-mediated manual workflows to automation supported by cloud services and mobile apps. Digital innovations have transformed the way we work with distributed, low-cost access to content and information services.
Enabling these digital innovations has forced developers to move compute, storage and networking resources from their traditionally centralized locations, such as data centers and clouds, to decentralized or distributed [edge] locations that are closer to where data is generated and consumed. This architectural shift is changing the economics of information systems, reducing the costs and significantly increasing the flexibility of computing and networking resources which, in turn, is changing how businesses operate. This shift to distributed systems is enabling a much larger number of businesses across the economy to access powerful new tools such as AI, IoT and new personalized microservices.
The Software Development Process
The underlying technologies that are enabling more complex adaptive systems are all in some way trying to break from today’s software and computing paradigms. To reach this goal, a new view of architecture is required in order to overcome today’s performance limitations. What are the major obstacles that need to be overcome?
- First, we need to achieve more distributed and intelligent infrastructure that enables powerful and pervasive networking and compute resources to be deeply embedded into our everyday lives to overcome infrastructural limitations on new, more dynamic software applications and solutions.
- Second, emerging applications are increasingly running on specialized hardware platforms such as wearables and VR headsets, application-specific integrated circuits, accelerators for AI and inferencing workloads, and field-programmable gate arrays for specialized use cases such as software-defined networking devices. This requires new development tools that can abstract and reduce development complexity to enable application-specific hardware devices to work seamlessly with software.
- Third, software applications today have become distributed, needing to work across multiple clouds, at the edge, and in diverse devices supporting multi-modal interfaces including voice, wearables, touch and AR/VR, in addition to web and mobile. Emerging software applications will increasingly need to support new and novel user experiences.
Fourth, we need better ways to manage data interactions and eliminate data boundaries — getting the application data close to its point of use while managing changes in the data quickly and consistently to enable fast, reliable and trusted application experiences — connecting users with the right code and the right data at the right time requires intelligent orchestration of application traffic and workloads across dynamic and distributed users and applications.
EVOLUTION OF HARDWARE DESIGNS
Perhaps the most important impact resulting from the shift to new distributed digital services architectures has to do with our infinite appetite for compute performance. In a world driven by data analytics and diverse workloads, the need for compute performance seems endless — and now with the influence of AI through new and merged workloads, the need for compute may prove to be infinite. This hunger for compute performance has spurred an onslaught of competing processor designs and architectures to help accelerate our workloads.
In many machines, one of the greatest computational resources is now their graphics coprocessors (GPUs), not just their primary CPUs. But GPU programming and memory models differ dramatically from conventional CPUs, and the relative performance characteristics of the different processors vary widely between machines.
Different processors within a system often perform best with different algorithms and memory usage patterns. Achieving the best overall performance may require mapping portions of programs across all types of resources in the machine. How we develop software for new higher application solutions requires better tools and processes to address the rapidly rising levels of complexity. But what causes these complexities?
- New intelligent hardware devices as well as cluster nodes in data centers are becoming heterogeneous (multi-core CPU and GPU) in order to increase their compute capabilities and performance.
- Code executing at the level of a node or device constantly needs to be ported to new architectures and accelerators to continue to improve performance.
- Most existing code is written for sequential execution, over-optimized for a particular architecture and difficult to port.
All of this creates two significant challenges to efficiently programming machines:
- How to program machines with increasingly heterogeneous computational resources
- How to port/migrate code from existing machines to new hardware designs and architectures
As hardware advances and diversifies, we’re entering what observers believe is a new generation of computer architectures. However, every time a new, world-changing silicon design is introduced it comes with a new software stack of tools. The ever-expanding hardware landscape can be daunting for software developers. While hardware innovations have positive impacts on price and functionality, they inevitably lead to spiraling software complexity on the back end.
SOFTWARE IMPACTS — ORCHESTRATING A NEW APPROACH TO DEVELOPMENT
These challenges don’t end with hardware innovations. Software today is tied to multiple parallel innovations that are increasingly integrated. Each new wave of hardware innovation is inevitably tied to and integral with cloud and networking performance, all of which requires new software. The exponential pace of these parallel innovations is making software development untenable.
Software architecture is quickly becoming the foundation of every technology-driven organization; not just hardware and software companies but also any organization that is building digital capabilities.
Enterprise software has undergone a dramatic evolution for 20 or more years. Today we have containerization — languages are less important, microservices are available everywhere, and it’s all enabling very powerful software solutions. But it’s also creating a huge amount of complexity. As the scale of data interactions grows, companies will need to make sure their software architectures and tools support new development and deployment protocols.
Companies are investing a great deal of time and money to develop new solutions, but they’re unable to scale innovations quickly. Each new wave of hardware platforms and cloud computing capabilities require too much customization and maintenance just to perform basic tasks. Without new methods to automate development, we risk constraining the growth of diverse new software opportunities.
Many industry participants will tell you that the answer lies with new low-code and no-code frameworks. We think this is partially but not completely true. Low-code tools typically offer a graphical UI to simplify the process of structuring a program, and then the system assembles the actual code that gives machines their instructions behind-the-scenes. The issue for the users of these tools comes when they—or more likely their developers—have a subtler problem and need to go deeper. They quickly find that “behind the scenes” is a room with no doorway in. If the interface doesn’t have a tool for it, it doesn’t exist. In this sense, typical low-code frameworks fail to leverage the greatest thing about software, which is its rapid movement and fluidity. They all manipulate the same programming problems, but their different solutions are locked away in a more tightly-coupled data structure that their simplified UI hides from the user. This leaves their customers “vendor-locked” into that particular platform to the exclusion of anything else.
With newer generation tools, there are multiple options for exporting the code and hosting it in a more traditional development environment – newer tools don’t lock customers into a “closed” SaaS provider platform, allowing users to maintain control and governance over their data and IP using either their own captive infrastructure or external cloud services provider.
Developers and users need a completely new approach to automating development and workflows – one where open-source software development tools and libraries are modular and interchangeable and where automation of software development and re-use of software components can be realized in a variety of flexible configurations.
DESIGN AND DEVELOPMENT CHANGES FOREVER
The fact that a rapidly expanding range of devices have the capability to automatically process and transmit information about status, performance and usage, and can interact with people, other devices and solutions anywhere in real time, points to the increasing complexity of applications. This only compounds when we consider the billions or more of networked devices that are being deployed.
The tools we are working with today to develop complex application solutions were not designed to handle the scope of new capabilities, the diversity of usage and devices, and the massive volume of data-points and interactions between and among systems. These challenges are diluting the ability of organizations to efficiently and effectively manage development. The fragmented nature of software development tools available today make it extremely difficult, if not impossible, to leverage new hardware, cloud and networking developments sprouting up across diverse domains and applications.
In fact, the rate of operational change today significantly exceeds the design-develop-deploy cycle of existing software development tools and is expected to increase five-fold or more over the next several years. This makes increasing the pace at which applications can be developed and deployed an important requirement.
We are reaching a critical juncture in complex systems and software development where organizations will soon be crying out for a completely new approach — one where the effort invested to develop new applications can be quickly and easily utilized again and again across an ever broader spectrum of domains, devices, cloud configurations and interaction schemes.
Developers expect evolving software development tools to be functional, ubiquitous and easy-to-use. Within this construct, however, the first two expectations run counter to the third. In order to achieve all three, a new approach is required — a common means of managing code that can orchestrate and leverage legacy and new development across families of interrelated hardware and diverse computing domains. ♦
