Systematic techniques for dealing with concurrency can be very helpful in concurrent programming. In his concurrent programming text, Andrews [2] describes a technique for developing concurrent programs based on first developing solutions using course-grained atomic commands and atomic await primitives (which are usually not available in real programming environments), then systematically transforming the solution to an implementation that uses available synchronization primitives. Transformations are known for semaphores, conditional critical regions, and monitors. In this paper, transformations are given for the synchronization constructs provided by the Java programming language [1]. Familiarity with the basic facilities to support concurrency provided by Java is assumed.
The software engineering industry suffers from almost unmanageable complexity both in the products it produces and in the processes of production. One of the current shortcomings in the software production process is the weakness of the models used. This paper makes observations on the role of knowledge in engineering and examines the central role of models and simulation. We develop an argument for the application of certain new forms of modelling methods in software engineering in order to impose more discipline and give a principled framework for building models that can support the software life-cycle. The concept of a model is examined in depth and different characteristics and types of model are defined. This introduces the relatively new concept of qualitative models and their use in the field known as model-based reasoning. Unlike previous knowledge-based methods, model-based reasoning has several important advantages. Although very few modelbased software projects exist, we illustrate how this approach can be developed by drawing on applications from traditional engineering. It is argued that, because qualitative modelling offers great power for addressing the issue of complexity, such models have considerable potential as high-level abstractions of software products. These could form the core of tools for the management and support of the software development process through the whole product life-cycle.
A number of applications in simulation and software testing require random number generation, both uniform and non-uniform. Although libraries are available for random number generation, there is no user-friendly tool to enable the user to use and build random number generators. This paper presents the RVGEN tool, developed at TRDDC. Using the tool, the software developer can design a random number generator specific to a particular pattern. The tool takes specifications at a high level and also partly in C++, and generates C++ code for a number of user-friendly functions. These include setting and getting of random variate parameters, GUIs for inputting parameters, validation of parameters, parameter input and output from a file, generation of random variate class declarations, generation of seeds for multiple streams, and testing of the random variate generator. The tool provides a number of classical, generalpurpose and empiric distributions by default.
We reveal a grey area in the specification of Java and of its implementation through the Java Virtual Machine (JVM): the treatment of initialization of classes and interfaces. We report the results of our experiments with different implementations of Java, which confirm the theoretical prediction of our work on mathematical models for Java [4] and the JVM [3], namely that the designers of Java and the JVM have used notions of initialization which do not match and which afflict the portability of Java programs. We also show that concurrent initialization may deadlock and that various current Java compilers violate the initialization semantics through standard optimization techniques.
The refinement calculus is a well-established theory for formal development of imperative program code and is supported by a number of automated tools. Via a detailed case study, this article shows how refinement theory and tool support can be extended for a program with real-time constraints. The approach adapts a timed variant of the refinement calculus and makes corresponding enhancements to a theorem-prover based refinement tool.
The ever increasing emphasis on distributed systems has led to advances in the client/server model and the emergence of component-based software development as an important paradigm in software engineering. Along with the new computer technologies it is necessary to reuse legacy code. Approaches to application development over, for example, the Internet are important if this is to be successful. This paper examines these issues and argues that incorporating the ideas of the component-based approach and reuse can significantly assist the application software developer. It demonstrates an approach through the development of an interactive/visual environment for component-based assembly.
When applications must keep their data structures persistent, additional effort beyond transient modeling is necessary to realize suitable persistent storage. The most convenient approach is the use of a persistent programming language (PPL), which offers internal mechanisms for storing and loading data transparently for the application programmer. An alternative to a PPL is a universal programming language that has been extended by persistence concepts for any data types. This paper introduces an extended generic mechanism that abstracts necessary functionality for realizing persistence of any C++ object structure. First, we discuss general problems of persistent storage and the motivation for this approach. The design aspects and the reasons for special features are described in detail with the data and implementation insides. Finally, we sketch the persistent data structure and present the integration of the library in three different example programs.
This article presents the architecture of the IBM San Francisco frameworks and provides additional information on the San Francisco layers and extension mechanisms. San Francisco leverages the power of Java and distributed object computing to provide a solid foundation for robust, Internet-enabled, cross-platform, scalable software solutions for specific industry domains. San Francisco components are designed as frameworks that provide an object-oriented infrastructure, a consistent application programming model and default business logic.
The definitions and discussions below were contributed via e-mail. They are arranged by date. The experts, listed alphabetically above, participated in this virtual round table during the first quarter of 1998.
This paper gives a synopsis of the SAP R/3 Business Framework. The architecture is based on an object-orientated approach using business objects and Business Components. Using this architecture together with a distribution model, distributed applications (distributed business processes) can be mapped and implemented. The spectrum of distributed applications extends from the simple integration of two components using a few interfaces to the integration of many components distributed across the globe.
Most design and evaluation of software tools is based on the intuition and experience of the designers. Software tool designers consider themselves typical users of the tools that they build and tend to subjectively evaluate their products rather than objectively evaluate them using established usability methods. This subjective approach is inadequate if the quality of software tools is to improve and the use of more systematic methods is advocated. This paper summarises a sequence of studies that show how user interface design choices for software development tools can be evaluated using established usability engineering techniques. The techniques used included guideline review, predictive modelling and experimental studies with users.
A component is a physical encapsulation of related services according to a published specification. These services can only be accessed through a consistent and published interface that includes an interaction standard. Accordingly, a component has a black box view captured by the published specification, and a glass box view showing implementation details. We claim that the following semantic model is general enough to represent all black box views of components we have discussed so far.
Research in compiler-compilers has contributed to facilitating the implementation of domainspecific programming languages and syntax-based software design. We present a formalism for the description of formal translations whose use requires no more than common procedural programming skills and an understanding of the EBNF notation. The soundness and applicability of the ideas presented have been proved by implementing the Depot4 metasystem. Its metalanguage, Ml4, extends EBNF in a symmetrical way; i.e., target descriptions utilise features already known from syntax definitions. The current implementation is by preprocessing. Simple use, flexibility and extensibility have been rated high. Applying principles of object-oriented programming, a concise and extensible system was built. A flexible access scheme allows the separate replacement of modules even during run time, thus enabling dynamic adjustment. New ways of application may originate from a more general view of source and target languages as well.
Component software addresses the fundamental requirement that software systems need to be composed from components. Potentially, each component can evolve on its own as a product. Composition may be static, much in the sense of traditional product assembly, but could just as well be dynamic. Dynamic assembly is even required in the increasingly important case of content-oriented solutions. In all cases the effectiveness of a component approach will rest on the degree of standardization achieved in a specific domain. This article provides a strategic comparison of the two major competing component software standards: COM and CORBA/JavaBeans.
Programmers’ mental representations of programs do not obey the order and immediate content of program texts. Multiple visible representations, or views, of programs help programmers to construct mental representations needed in, e.g., maintenance tasks. We have implemented VinEd, a language-independent editor framework that supports an unlimited number of user-definable and editable views. Views are defined by transformation programs that construct views from the original representation. VinEd extends the notion of views to any activity that can be based on the original program, e.g., program compilation. Thus VinEd can be extended to include a complete set of programming tools.
RefStep is a simple tool for program refinement intended to provide a minimal user interface that supports basic mathematical manipulations of terms used for transforming algebraic specifications into imperative programs under the control of refinement rules. Even though the tool has been designed primarily for program refinement, its interface is well suited for general calculational proofs.
Fixed end-system protocols are unable to support the wide range of applications requirements on top of current networks without adding overhead in the form of unnecessary functionality for multiple combinations of application requirements and networks.This paper presents the Real-time Wide Area Network Dissemination Architecture Protocol (RWANDA), which dynamically configures multimedia protocol stacks to support a wide range of application requirements and to increase performance. It overcomes: synchronous limitations by providing an asynchronous group communication model. Applications only pay for required quality of service (QoS) such as multicast, virtual synchrony and encrypted communication.In RWANDA, information sources use channels to disseminate information to a potentially large and changing set of channel subscribers. RWANDA recognises the differing media characteristics and transport requirements of multimedia by providing a protocol composition framework that extends to incorporate yet unsupported communication protocols, qualities of service and optimised multimedia stacks. RWANDA provides an asynchronous foundation necessary for developing a large-scale wide area network continuous media protocol.
The on-line classroom project includes support for Web-based exams as well as a C++ program compile-execute-and-grade server. The paper discusses the design and implementation of the system as well as the experience to date.
The choice of the first-course programming language for a university-level computer science curriculum has pedagogical ramifications in terms of comprehensibility and mastery of fundamental concepts. This paper compares the merits of Java and Modula-3 as a firstcourse language.
