|
|
In today's continuously evolving business environment, the ability to change and adapt helps create the distinctive capabilities that underpin high performance. A critical enabler of change is a powerful, responsive and highly flexible IT system.
In this context, the challenge for companies aspiring to become high-performance businesses is to find a way to better control the development costs of their IT system's increasingly complex underlying software and achieve greater productivity and agility. Toward that end, Accenture believes emerging model-centric approaches have the potential to significantly overcome deficiencies in traditional software development methods.
In particular, model-driven development (MDD) has the potential to industrialize the software development process by promoting models as the primary artifacts that developers create and maintain. These models, which are created in domain-specific languages (DSLs)—small, highly focused languages that are created for specific problems, platforms or tasks—rather than computer languages, are then transformed further into models or directly to code (see Sidebar, below).
|
Model-centric approaches operate at a higher level of abstraction than traditional methods; they specify the intent of an application rather than the procedure. Far from commoditizing IT, model-driven software development will force IT processes and systems to be organized around business functions and processes rather than applications and technology platforms. As a result, they will play a central role in making organizations more agile and better able to execute distinctive, innovative business strategies in support of high performance.
Agility, Productivity, Quality
There is nothing fundamentally new, in technology terms, that gives rise to MDD. It is an evolutionary practice in software development focused on achieving systematic reuse through a higher level of abstraction. Unlike traditional software engineering processes, MDD requires the careful and time-intensive upfront design of domain-specific languages and models. The business domain experts model the business processes, while software engineers create the technical models that will generate the code. These modeling processes can be complex and time-consuming, but once they're complete, new development goes faster, because code is then automatically based on user requirements.
A key benefit is that as business requirements change, higher-level models enable faster software modifications than traditional approaches, boosting agility. Testing and deployment can also be completed faster, since model-generated code contains fewer errors than code developed by general-purpose programmers. That, in turn, increases productivity and quality.
Maintenance is significantly reduced, too, since only higher-level models need to be maintained, which is not the case with implementation code. DSLs and reusable models also provide consistency within and across projects, which speeds the process.
Finally, model-centric approaches enable platform and vendor independence, since function is separated from implementation. Systems developed under MDD theoretically can be re-implemented quickly on an alternate platform.
Although model-driven software development is not currently in widespread use, progressive companies are now evaluating MDD and emerging MDD-enabled tools. Major tools vendors such as Microsoft Corporation, IBM Rational and Borland Software Corporation have integrated MDD capabilities into their tool sets, touting it as a way to simplify software development and reduce complexity and cost.
In addition to the commercial vendors, The Eclipse Foundation is gearing up to release a rich set of open source tools to support MDD within Eclipse. Using these tools, developers maintain the application models at the same time they modify the code, switching back and forth between modeling, development and testing.
The MDD adoption cycle will likely follow one of several different scenarios. For example, according to the major tools vendors, MDD will become the de facto approach for designing, building and maintaining all types of software systems, dramatically transforming every aspect of software engineering. However, based on Accenture's extensive experience developing and managing complicated systems, we are less optimistic.
Model-driven software development carries the real danger of being locked into a specific domain-specific language created for the particular application, forcing companies to stick with the application long enough to justify that investment. For this and other reasons, Accenture does not endorse the full-adoption MDD scenario put forth by the tools vendors.
Nor does Accenture subscribe to the most pessimistic view of MDD. In this scenario, MDD will lose focus, and its lasting effect will be seen only in contributions to the overall field of software engineering (such as better modeling tools and techniques for the reuse of models). We believe the concepts that underlie MDD, such as model-centricity, have significant benefits that will greatly impact on software development into the future.
Instead, Accenture believes there is a strong likelihood MDD will become the prevailing development approach for complex and high-risk niche projects. For example, companies should (and will) evaluate MDD for software that exhibits a high degree of coupling and cohesion (as in cases where multiple, closely related versions need to be created and reused within a product family).
Other good candidates are time-consuming tasks at the periphery of development activity. One such task is software configuration. At Accenture Technology Labs, we have proven that MDD can dramatically help with these tasks, yielding simpler deployments and a decrease in configuration errors.
With its emphasis on creating flexible models of software code, we believe model-driven development is a perfect complement to a service-oriented architecture (SOA), which focuses on modeling business processes. MDD and SOA are independent concepts that tackle different issues in systems design, but they share a common model-centric philosophy.
Both enable companies to create highly flexible IT systems that are more responsive to business change. MDD boosts agility in software development and supports the better reuse of components. These are also two key features of an industrialized SOA application. One of the goals of the Accenture Lab for SOA Innovation, launched in July 2006, is to explore the value of MDD and domain-specific languages in mature SOA environments.
Model-centric approaches to software engineering—namely, MDD working in concert with SOA—will enable faster time to market and enhance IT's value to the business—a critical step on the path to high performance.
Sidebar: The Four Components of Model-Driven Development
-
Domain-pecific languages (DSLs) are designed for specific tasks in a particular domain—as opposed to general-purpose programming languages, like Java. Using a model-driven development tool set, organizations can create custom DSLs to model their processes and applications. DSL examples include SQL (domain: databases), HTML (domain: webpage layout), BPEL (domain: business processes).
-
Model-based applications, written in one or more DSLs, specify the application's functional intent rather than its procedural details. Since applications are written in a language specifically tuned to the domain, they are a more compact and expressive representation of the application functionality than can be provided by a general-purpose programming language.
-
Transformation rules drive a transformation engine to translate the DSL-based application into code for a target language or platform. A series of transformations will be used to translate the application into executable code. The transformation engine is conceptually similar to a compiler.
-
A runtime environment contains higher-level APIs and code libraries to relieve the transformation engine of the burden of generating raw system-level code—a more efficient and less error-prone approach. Some of these code libraries will be custom created as part of developing the transformation engine; as such, they must be maintained consistently with the DSLs and the transformation engine for the application to execute properly.
-
Don Rippert is based in Reston, Virginia.
To Top