Describing Information Systems: Moving Beyond UML

Session Overview

Part of the job of the software architect is to create a coherent and useful architectural description so that the architecture of their system can be communicated to and understood by interested stakeholders (including the architect himself).

UML is the defacto standard language for describing software models, but it is primarily an object-oriented software design notation and many architects find it difficult to express their ideas using it. They prefer [[http://custom-essay-writing-service.org/order.php|custom essays]]much

Alternatives to UML have been proposed in both the academic community (in the form of ADLs like ACME, xADL and Wright) and the industrial community (for example Gregor Holpe's "gregorgrams" notation used in his EAI patterns book). However, these alternatives have not been widely adopted by information systems practitioners.

This situation means that many architects end up inventing their own informal architectural design notations in order to describe their systems. This can be problematic for a number of reasons, not least the wasted effort involved in repeatedly reinventing notations, confusing inconsistency between architectural descriptions and the likelihood of confusion and misunderstanding when stakeholders need to understand and interpret new notations.

In this workshop, the participants attempted to identify the key requirements of a language for describing software architectures and sketching their own visual language for defining software architectures.

Materials

The slides used to run the session are here: [u1]

Outputs

In Exercise 1, the participants were asked to identify some of the architectural views that particular stakeholders would be interested in and the nature of their interest in each.

The output of Exercise 1 is shown below.

Stakeholder	Viewpoint	Requirement of the ADL
Business User (“proxy” user) for an e-commerce system	Functional	user experience (what is “seen” by the user)
		performance
Acquirers	?	System qualities (eg latency, throughput)
Maintainers	Information	data structure and data ownership
	Functional	Information rich components
	Operational	Operational processes
Support	Operational	dependencies
	Deployment	sequences of operation
	Functional	components in the system

We skipped Exercise 2 (limitations of UML) in the interests of time and moved on to Exercise 3, where participants were asked to start sketching what their ideal ADL might look like.

Some of the outputs were as follows:

One group focused on information structures and thought about how they would represent the information (rather than the way the ADL would look). Their meta model is shown below.

[u2] [u3]

The second photograph shows their thoughts on how they'd use the meta model, allowing a number of visualisations of it including specific graphical notations and standard notations like UML and 'SysML?? that would allow use in other tools.

Another group focused on a very specific problem, that of persistence mechanisms. As the photograph below shows, they identified the pieces of a persistence solution and then realised that a key part of an ADL for them would be to allow mechanisms such as this to be defined in detail somewhere but then refered to by a summary notation (which is what the special component icon at the bottom of the flipchart is) or [[http://custom-essay-writing-service.org/order.php|order essay]].

[u4]

A third group decided that extending UML was the most promising approach (in the way shown on the slides in the presentation) but that for architecture work to be valuable, it needed to be integrated with other design artefacts like business process modelling. This is shown in the diagram on the flipchart below:

[u5]

This group also identified the need for tool support as paramount, with the key requirements being

• Allowing a separation between a view and the underlying architectural model, and allowing both to be accessed via the tool.
• Allowing inconsistent views (i.e. diagrams) to be created while the architecture is created and not storing these as part of the formal model.
• Allow hybrid views to be created where elements from different view types are combined to illustrate a particular point.

Results

A summary of the main points made in the workshop would be:

• Support for multiple views of an architecture is crucial.
• Being able to handle informality at various points in the design process is important.
• Integrating architectural design with other models (e.g. business process models) is important.
• The ability to define complex structures (or mechanisms) and then represent these structures via a simple notation when used in other places seems like a useful feature (e.g. the persistence mechanism example developed by one of the groups).
• Separating the model from its visualisation was a need identified by a number of groups.

In true SPA tradition, these aren't the results we were expecting and so they're all the more interesting because of that!

We'd like to thank all of the participants in the session for their ideas and participation. http://www.popularreview.com/products/hypervre-review/ hypervre

http://www.best-webhost-review.com web hosting reviews http://www.professays.com/ - custom essay papers http://www.hqessays.com/ - buy essay papers http://internethostingweb.com/ http://electroniccigarettesmokes.com/ http://gas4freeweb.co.cc/ http://earth4energyweb.co.cc/

http://solvesudoku.net solving sudoku

http://sudokutips.us/sudokustrategies.html sudoku strategies

EoinWoods & NickRozanski

Back to SpaTwoThousandAndSixOutput http://echealthinsurance.com/ health insurance quotes http://ecautoinsurance.com/ auto insurance quotes http://itsinsurancequotes.com/ insurance price quotes]