Embedded Files
- Current Business Environment and Drivers
- The On Demand Business: As businesses are expected to be more adaptable and flexible, so too are the IT systems that enable them.
- Business Relevance:
- There is a strong focus on IT departments to deliver business value.
- Software must be business relevant.
- Miscommunication between business and IT people can lead to projects that, successful from an IT-delivery viewpoint, are deemed business failures.
- Cost Control:
- The days of IT being invested in on the strength of its promises are long gone.
- IT departments now operate under strong budget constraints and are expected to demonstrate value for money.
- Increasing Complexity:
- Software systems continue to increase in scale and complexity to meet business needs.
- Techniques that work well for small-scale development do not necessarily scale to enterprise-wide initiatives.
- Skills Availability:
- The sophistication of today’s IT platforms means that specialists’ knowledge is required to deliver software.
- Many organizations struggle to find sufficient skilled professionals to support their development.
- In addition, projects often depend on key individuals and suffer significantly if those individuals leave a project or organization.
- Changing Middle-ware Environment:
- Today’s applications are deployed to a huge variety of middleware platforms, and the rate of change in platform technology is showing no sign of slowing up.
- Businesses want to take advantage of advances in middleware but do not want to repeatedly rewrite their applications.
- A Model-Driven Approach to Software Development
- Model-driven development is a style of software development where the primary software artifacts are models from which code and other artifacts are generated.
- A model is a description of a system from a particular perspective, omitting irrelevant detail so that the characteristics of interest are seen more clearly.
- Software models are typically expressed in the Unified Modeling Language (UML).
- UML is a language for specifying, visualizing, and documenting software systems.
- UML provides a visual notation and underlying semantics for software models.
- UML also has a standard machine-readable serialization format, thereby enabling automation.
- Software models hide technical implementation details so that a system can be designed using concepts from the application domain.
- Model-Driven Development of Complex Software
- Despite significant advances in programming languages and supporting integrated development environments (IDEs), developing these complex software systems using current code-centric technologies requires herculean effort.
- A significant factor behind the difficulty of developing complex software is the wide conceptual gap between the problem and the implementation domains of discourse.
- Bridging the gap using approaches that require extensive handcrafting of implementations gives rise to accidental complexities that make the development of complex software difficult and costly.
- The term Model-Driven Engineering (MDE) is typically used to describe software development approaches in which abstract models of software systems are created and systematically transformed to concrete implementations.
- Advances in hardware and network technologies have paved the way for the development of increasingly pervasive software-based systems of systems that collaborate to provide essential services to society. Software in these systems is often required to:
- (1) Operate in distributed and embedded computing environments consisting of diverse devices (personal computers, specialized sensors and actuators),
- (2) Communicate using a variety of interaction paradigms (e.g., SOAP messaging, media streaming),
- (3) Dynamically adapt to changes in operating environments
- (4) Behave in a dependable manner
- Model Driven Engineering (MDE) primarily concerns with reducing the gap between problem and software implementation domains through the use of technologies that support systematic transformation of problem-level abstractions to software implementations.
- The complexity of bridging the gap is tackled through the use of models that describe complex systems at multiple levels of abstraction and from a variety of perspectives, and through automated support for transforming and analyzing models.
- A problem-implementation gap exists when a developer implements software solutions to problems using abstractions that are at a lower level than those used to express the problem.
Page updated
Google Sites
Report abuse