Guest Post: How the Cloud is Changing the Way Developers Work
Just because a business moves its systems to the cloud, it doesn't mean less work or opportunity for developers. Cloud computing puts more resources and tools at a developer’s fingertips, with scalable infrastructures and development platforms. Of course, there’s a lot of hype -- and some hype-sters would have you believe when it comes to cloud development all you have to do is open a browser, put in your credit card, and your apps are almost done. But the laws of physics still prevail -- developers need to monitor, maintain, and ensure their cloud apps are reliable.
As part of our ongoing series on the impact of cloud technology on the tech industry, Phil Marshall of Black Duck Software takes an in-depth look at what developers need to know about cloud computing, and how it's changing and shaping the nature of their work.
How the Cloud is Changing the Way Developers Work
Phil Marshall, Senior Product Marketing Manager, Black Duck Software
The cloud offers developers a platform for innovation and also presents a set of interesting challenges. Made viable on both open source and proprietary platforms, from Amazon EC2 and Microsoft Azure to OpenStack and VMware Sphere, the cloud also gives developers opportunities -- the ability to scale up development to innovate quickly, capability for self-service and self-provisioning without having to go through an IT request, and breakthrough efficiencies because hardware and software resources can be provisioned in a few hours instead of several weeks while still adhering to standardized IT processes.
Arguably the most interesting and innovative cloud work is coming out of the FOSS development community, where the use of open source provides the potential for accelerated development at low cost. Hadoop, Hyperic and Eucalyptus are just a few examples of cloud-focused open source projects to which developers are contributing. But how is that work different than, say, developing software for a hosted application? What has changed for developers in the cloud? It turns out, not as much as you might think.
Developers face a number of familiar challenges when developing for the cloud: reliability, exception handling, standards (or lack thereof), choosing frameworks/environments, language choice, IaaS and PaaS-related decisions and governance/management issues are but a few. Let’s look at these challenges, and then move to opportunities.
Reliability, resilience, and recovery
We often hear people new to the cloud wondering if cloud-based virtual servers are as reliable as the high-availability, expensive boxes in most datacenters. Cloud services vendors -- SaaS, IaaS and PaaS -- would probably say they are. And unless a corporate datacenter has hot/cold site capabilities in another location, there’s still a single point of failure, whereas Google’s virtual servers solve the reliability issue by providing a highly-redundant cluster with excellent reliability and availability. The really important point here is that reliability and resilience are critical attributes for any infrastructure, virtual or physical, and any application, behind a firewall or in the cloud.
Not all clouds are built the same, though. For developers, this means a responsibility (read: opportunity) to build resilient cloud applications and there are some best practices to consider. Recovery management is a one example; developers need to build in capabilities to recover if the application goes down, and also must consider how to recover. While ensuring reliability, resilience and recovery aren’t unique to cloud applications, it’s something to plan for in development.
Here’s another example. Exception processing, a necessity in any programming context, is a different matter in the cloud than when developing inside the firewall. In an perfect world, one with ideal programs and applications, a program moves along smoothly and never hits an exception -- a null value where it’s expecting a different answer; a query that returns too many answers or none at all; list exceptions, pointer exceptions, and so on. Any of these exceptions can bring an application stuttering to a halt, behind the firewall or in a cloud. In the cloud, exception handling moves up a level. Managing timing, calls or access to external services (e.g. shipping data in the middle of a transaction), or handling queries and transactions in a cloud-based financial services application -- these are more challenging development tasks to solve due to interoperability, latency, issues of access rights, lack of physical access, and process changes.
Kamesh Pemmaraju of the Sandhill Group says of the cloud, “Developers should learn new engineering techniques for failure resilience and handle these at the application level.” Design for failure. In other words, assume the worst (as Dogbert says, “I take that as a challenge”). Make sure all components used in a cloud application are scalable and independent so they can run concurrently on multiple nodes, limiting the impact of failures. Design threads to automatically restart after a failure, returning to the last known state. Make sure application components are loosely-coupled with few hard dependencies. Trust cloud infrastructures to implement multi-threading and parallelization, which might be costly in a behind-the-firewall application but are easily implemented at the API level in the cloud. With multiple threads and parallel processes, failures in the cloud are more manageable. In short, developers need a new paradigm for developing applications for the cloud.
Cloud development has been a bit of a free-for-all from a standards point of view. As usual, there are de-facto standards or what used to be called reference implementations (Amazon EC2 is an example); consortium-lead standards such as those proposed by the Open Cloud Consortium and OpenStack; and standards-body standards, such as the Open Cloud Computing Interface (OCCI), a network protocol for managing cloud computing infrastructure being drafted by the Open Grid Forum. The takeaway: it’s early days for standards. The good news for developers: there are still many ways to solve problems without worrying overmuch about being standards-compliant. One safe approach developers can take is to build additional layers of abstraction into cloud applications so there’s more chance that a change in infrastructure won’t ripple too far into the application. Nevertheless, here, as in much of computing, the market will lead the development of standards.
Frameworks and environments
A cloud developer’s best friend may well be the framework or platform he or she chooses. Cloud computing frameworks and platforms designed to support integration with web services, scalability in private and public clouds, and manage and store cloud data are available, and most are based on open source projects. And while many existing open source components need to be cloud-enabled, the FOSS community will no doubt port these components to the cloud as momentum continues to grow behind cloud computing
When Black Duck looked in its KnowledgeBase (which contains information on +300,000 projects) for data on cloud development, it found that most open source projects don’t self-identify as “cloud projects.” Indeed, only about 400 do. Notable projects include Hadoop, an Apache project that is a collection of sub-projects like MapReduce to support development of software for distributed computing; Eucalyptus, a project that provides software for creating private clouds; Hyperic, a project providing open source software for managing applications in the cloud and virtual environments; deltaCloud, an Apache project that provides an API to different cloud environments; OpenStack, the cloud standards effort/environment backed by Rackspace, NASA and others; and Open ECP, described as an "open source fork of the Enomaly Elastic Computing Platform."
Development languages and tools for the cloud are familiar: Java, the Perl stack, JBoss middleware, and the tools provided by the environments/platforms mentioned above. Developers can use Hadoop MapReduce, for example, to simplify the development of applications that process large amounts of data, in parallel, on distributed nodes; Memcached can be used to speed up dynamic web applications by alleviating database load.
In the cloud, the power tool of choice may be the API. APIs are the gateway to the platform or infrastructure in which a developer works, the gateway to the cloud instance they’re working with, and the gateway to the applications they are building for, or running in, the cloud. A number of start-ups have emerged to provide cloud APIs, or provide management tools for cloud APIs (e.g. Apigee, which describes itself as a "new Internet of APIs").
Governance and management
Because much of the cloud is built on open source, governance, management, and licensing are big issues - developers may not think these are developer issues per se, but license choice, compliance, and responsible use all spring from code choices. If you’re using an open source framework like Hadoop, for example, your use is governed by the relatively permissive Apache license. Code from other projects or frameworks may by licensed under one of the two versions of the Affero GPL license, a copyleft license written to close the “ASP loophole” in the GPLv2. The Affero GPLv3 license, a Free Software Foundation license, requires that source code be made available to any user of a network (web service) when Affero-licensed software is deployed as a network service. For developers writing applications for the cloud, choosing a license -- or re-using FOSS components with varying licenses -- is a development decision.
The effort required to manage FOSS licenses is only one aspect of this decision. Deciding to re-use FOSS code assumes that the developer is responsible for managing that use, i.e., developers must understand compliance requirements and governance processes when they choose and use FOSS components. A variety of FOSS and enterprise solutions are available to help developers manage re-use of open source components. Spreadsheets aren’t enough -- go for an enterprise-strength solution, particularly if you are writing code for export use.
Some say that “cloud” is really marketing-speak for “distributed computing.” Another view might be that it’s the mature version of distributed computing. As the cloud market itself matures, we will see cloud vendors move up the stack, and opportunities for developers to accelerate innovation will become even more pronounced.
In fact, most cloud vendors are even now moving up the stack and beginning to look more like Platform-as-a-Service plays. Amazon started out as a pure IaaS player, but look at the new services they are offering and they are clearly starting to look more like a platform. VMware also now offers a platform with its recent acquisition of SpringSource, which will enable the company to build a more complete offering rather than remain a virtualization provider. SalesForce, which broke through as a SaaS offering, is rapidly making the transition from a pure SaaS (CRM) company to a PaaS player with its Force.com platform.
These developments point to a conclusion: PaaS will be a sweet spot where future innovation and value will be generated. It will be the battle ground where cloud vendors will vie for dominance, which means opportunity for developers.
Don’t forget the development managers
Then there are the opportunities the cloud offers to development managers, e.g. the ability to manage development and provide innovation at lower cost, based on shifting expense from Capex to operating expense.
Of course, shifting costs from one column to another may not interest developers nor deliver any real value. Innovation is the path to value in the cloud. With open source, developers can concentrate on writing code that is differentiated and adds value, while re-using OSS components for areas of development that are non-differentiated.
Hype aside, the cloud is where a lot of developers are headed. A successful cloud developer, in addition to writing good cloud-ready code, will need knowledge and skills related to both the use of FOSS and cloud platforms. Begin by searching for FOSS components to use in your development. Look at the big cloud projects and platforms and see what you can use, where you can contribute back, and which components can be integrated into your development easily. Cloud computing is chiefly of value to developers because, in combination with FOSS, it gives them access to scalable infrastructures and platforms at low cost, re-usable components, and lower management overhead -- all of which lower the barrier to entry to develop innovative code that will differentiate their offerings.