A fundamental part of a Computer Science degree is learning to program. Rather than starting students on a full commercial language, we favour using a dedicated "teaching language" to introduce programming concepts. At the same time, we want to introduce students to popular tools that assist in the software development process. However, up until now our teaching language, Kenya, has not been supported by professional IDEs. Therefore, we have been unable to progress smoothly from first principles to the state of the art within one environment. We present work that integrates the Kenya language into the Eclipse environment. Students can now become familiar with the major features of a professional IDE while learning to program, and experience a smooth transition to commercial languages within the same environment. One of the hardest things to teach students is good programming style. Compilers reveal syntactic and type errors, but do not analyse style. We have harnessed as-you-type code checking, as seen in Eclipse's Java development tools, to provide advice on program style as well as correctness.
We present a tool that provides effective graphical animations as a means of validating both goals and software designs. Goals are objectives that a system is expected to meet. They are decomposed until they can be represented as fluents. Animations are specified in terms of fluents and driven by behaviour models.
Constructing rigorous models for analysing the behaviour of concurrent and distributed systems is a complex task. Our aim is to facilitate model construction. Scenarios provide simple, intuitive, example based descriptions of the behaviour of component instances in the context of a simplified architecture instance. The specific architecture instance is generally chosen to provide sufficient context to indicate the expected behaviour of particular instances of component types to be used in the real system. Existing synthesis techniques provide mechanisms for building behaviour models for these simplified and specific architectural settings. However, the behaviour models required are those for the full generality of the system architecture, and not the simplified architecture used for scenarios. In this paper we exploit architectural information in the context of behaviour model synthesis from scenarios. Software architecture descriptions give the necessary contextual information so that component instance behaviour can be generalised to component type behaviour. Furthermore, architecture description languages can be used to describe the complex architectures in which the generalised behaviours need to be instantiated. Thus, architectural information used in conjunction with scenario-based model synthesis can support both model construction and elaboration, where the behaviour derived from simple architecture fragments can be instantiated in more complex ones.
Scenarios and goals are effective and popular techniques for requirements definition. Validation is essential in order to ensure that they represent what stakeholders actually want. Rather than validating scenarios and goals separately, possibly driving the elaboration of one through the validation of the other, this paper focuses on exploiting the relation between goals and scenarios. The aim is to provide effective graphical animations as a means of validating both. Goals are objectives that a system is to meet. They are elaborated into a structure that decomposes declarative goals into goals that can be formulated in terms of events that can be controlled or monitored by the system. Scenarios are operational examples of system usage. The relation between scenarios and goals is established by means of fluents that describe how events of the operational description change the state of the basic propositions from which goals are expressed. Graphical animations are specified in terms of fluents and driven by a behaviour model synthesised from the operational scenarios.
Plugins are optional components which can be used to enable the dynamic construction of flexible and complex systems, passing as much of the configuration management effort as possible to the system rather than the user, allowing graceful upgrading of systems over time without stopping and restarting. Using plugins as a mechanism for evolving applications is appealing, but current implementations have limited functionality. In this paper we present a framework that supports the construction and evolution of applications with a plugin architecture.
To be able to build systems by composing a variety of components dynamically, adding and removing as required, is desirable. Unfortunately systems with evolving architectures are prone to behaving in a surprising manner. In this paper we show how it is possible to generate a snapshot of the structure of a running application, and how this can be combined with behavioural specifications for components to check compatability and adherence to system properties. By modelling both the structure and the behaviour, before altering an existing system, we show how dynamic compositional systems may be put together in a predictable manner.
The paper describes a tool-supported approach to the design of Web applications. Specifically, the paper presents the use of behavioural models augmented with web-based simulations of user interfaces that permit validation and usability assessment of systems by end users in advance of implementation. The goal is to correct architectural design decisions that adversely impact usability early in the design cycle when correction is relatively inexpensive. The behavioural model of a system captures the interactions between the different users roles and the set of components that constitute the application. A visual scenario-based language is used to specify interactions and the tool LTSA-MSC is used to synthesise the required behavioural model. The tool supports a visual representation of this model that is animated in response to user-interaction with the simulated Web interface. The combination of these facilities permits agile incremental elaboration of a system design.
Using plugins as a mechanism for extending applications to provide extra functionality is appealing, but current implementations are limited in scope. We have designed a framework to allow the construction of flexible and complex systems from plugin components. In this paper we describe how the use of modelling techniques helped in the exploration of design issues and refine our ideas before implementing them. We present both an informal model and a formal specification produced using Alloy. Alloy’s associated tools allowed us to analyse the plugin system’s behaviour statically.
In this paper we discuss an approach for simulating the behaviour of interactive software systems, before starting on any of the actual implementation, based on a model of the system at the architectural level. By providing a mock-up of the final user interface for controlling the simulation, it is possible to carry out usability assessments of the system much earlier in the design process than is usually the case. This means that design changes informed by this usability assessment can be made at this early stage. This is much less expensive than having to wait until an implementation of the system is completed before discovering flaws and having to make major changes to already implemented components. The approach is supported by a suite of cooperating tools for specification, formal modelling and animation of the system.
We present a tool that supports the elaboration of behaviour models and scenario-based specification by providing scenario editing, behaviour model sysnthesis and model checking for implied scenarios.
Using plugins as a mechanism for evolving applications is appealing, but current implementations are limited in scope. Plugins are optional components which can be used to enable the dynamic construction of flexible and complex systems, passing as much of the configuration management effort as possible to the system rather than the user, allowing graceful upgrading of systems over time without stopping and restarting. In this paper we explore the design space of plugin architectures, present a framework that addresses the aforementioned issues, and demonstrate some examples of applications implemented using our plugin architecture. terms of plugin components.
This article discusses the comparison between software engineering and other engineering disciplines, taking as examples the aerospace, construction and automotive industries. We compare the processes used and the roles played by different team members in the different industries.
A fundamental part of the first year of a computing degree is learning programming. In order to become good programmers, students need to be able to concentrate on understanding the problems that they are solving, techniques and algorithms. This can be impeded by the need to learn the syntax of a complex programming language. Teaching languages provide simple syntax, but students are often not happy learning a language which they do not see as having commercial applications.
This thesis details the design of a teaching language, Kenya, and a translation system for converting code written in the teaching language into Java code. This gives the progressing student a stepping stone to Java, whilst letting the beginner concentrate on the principles of good programming. The report also encompasses the design of a development environment for writing programs in this language.