An overview of Mirjam and WeaveC

In this chapter, we elaborate on the design of an industrial-strength aspectoriented programming language and weaver for large-scale software development. First, we present an analysis on the requirements of a general purpose aspect-oriented language that can handle crosscutting concerns in ASML software. We also outline a strategy on working with aspects in large-scale software development processes. In our design, we both re-use existing aspect-oriented language abstractions and propose new ones to address the issues that we identified in our analysis. The quality of the code ensured by the realized language and weaver has a positive impact both on maintenance effort and lead-time in the first line software development process. As evidence, we present a short evaluation of the language and weaver as applied today in the software development process of ASML

A Case for Custom, Composable Composition Operators

Programming languages typically support a fixed set of com- position operators, with fixed semantics. This may impose limits on software designers, in case a desired operator or semantics are not supported by a language, resulting in suboptimal quality characteristics of the designed software system. We demonstrate this using the well-known State design pattern, and propose the use of a composition infrastructure that allows the designer to define custom, composable composition operators. We demonstrate how this approach improves several quality factors of the State design pattern, such as reusability and modularity, while taking a reason- able amount of effort to define the necessary pattern-related code

Designing Programming Languages for Writing Maintainable Software

Maintainability is crucial to the long-term success of software projects. Among other factors, it is affected by the programming language in which the software is written. Programming language designers should be conscious of how their design decisions can influence software maintainability. Non-functional properties of a language can affect the readability of source code in ways beyond the control of programmers. Language features can cause or prevent certain classes of bugs, and runtime issues especially can require significant maintenance effort. Tools external to the language, especially those developed and distributed by language implementers, can aid in the creation of maintainable software. Languages designed with these aspects in mind will ease the burden placed on software maintainers by facilitating the development of robust, high-quality software

Textual Authoring for Interactive Narrative

Narrative design and implementation in interactive softwares has always possessed an intrinsic issue, in that the person or persons with the responsibility of authoring the narrative will most likely lack ability in programming. Because the narrative does eventually become implemented in software, the in uence the technical side has on the creative side is unavoidable. The design of the March22 Engine, its scripting language, and its accompanying authoring tool are all designed to facilitate those of least programming ability, whilst not limiting those of greater ability. By making the scripting language as similar to a screenplay as possible, and showing the ow of narrative via charts, the writer is left with as little programming requirements as possible, whilst still able to produce quality narrative

Data-parallel programming with multiple inheritance on the connection machine

The demand for computers is oriented toward faster computers and newer computers are being built with more than one CPU. These computers require sophisticated software to program them. One such approach to program the multiple CPU machines is through the use of object-oriented programming techniques. An example of such an approach is the use of C* on the Connection Machine. Though C* supports many of the object-oriented concepts, it does not support the concept of software reuse through inheritance. This thesis introduces a new language called C*±+ , an extension of C* language to support inheritance. We also discuss the issues invloved in the implementation of multiple inheritance in programming languages. This thesis describes the differences between C** and C* . It also discusses the various issues involved in the design and implementation of the translator from C** to C* . It also illustrates the advantages of programming in C*++ through an example. Since C*++ is designed to support software reuse which allows the users to create quality software in shorter time, it is anticipated that C*+ will have widespread use in programming the Connection Machine

Managing software complexity of adaptive systems

To survive under competitive pressure, embedded system companies build systems that can deal with changing customer needs and operating conditions, and deterioration of the hardware over the lifetime of the embedded system. Engineers face the challenge to design such adaptive systems, while keeping hardware costs low. To accomplish this, increasingly sophisticated control strategies are being designed and implemented in embedded systems. An example of such a sophisticated control strategy is runtime optimization of multiple system qualities, such as power consumption and productivity, and dynamically making trade-offs between such qualities (or objectives) based on (varying) user needs.\ud \ud Large part of the control logic of embedded systems is implemented in software. The implementation of sophisticated control strategies introduces additional complexity in embedded control software. Part of this complexity is inevitable: it is a result of essential complexity in the selected control strategy. However, the lack of structured methods to design and incorporate sophisticated control strategies in software and the lack of proper abstraction mechanisms in programming languages to express these strategies introduce accidental complexity in the software. Accidental complexity reduces software quality with respect to several quality criteria such as comprehensibility, reliability, maintainability and reusability. The subject of this thesis is how to manage the complexity introduced by sophisticated control strategies, and how to reduce the impact of this complexity on software quality. \ud \ud This thesis provides three main contributions. First, this thesis proposes a novel technique to compose domain-specific models of physical characteristics (physical models) with control software modules written in a general-purpose programming language. As such, it combines the benefits of domain-specific abstractions in a domain-specific modeling language with the freedom of a general-purpose programming language. Second, this thesis provides a method for runtime verification of models of physical characteristics that are utilized in embedded control software, as such models may be wrong or inaccurate. Third, this thesis presents a structured method to include multi-objective optimization solutions in the architecture of embedded control software. This method prevents tailored solutions and tight integration of optimization algorithms with control software modules

Web-based Tools for the Analysis of DNA Microarrays

End of project reportDNA microarrays are widely used for gene expression profiling. Raw data resulting from microarray experiments, however, tends to be very noisy and there are many sources of technical variation and bias. This raw data needs to be quality assessed and interactively preprocessed to minimise variation before statistical analysis in order to achieve meaningful result. Therefore microarray analysis requires a combination of visualisation and statistical tools, which vary depending on what microarray platform or experimental design is used.Bioconductor is an existing open source software project that attempts to facilitate analysis of genomic data. It is a collection of packages for the statistical programming language R. Bioconductor is particularly useful in analyzing microarray experiments. The problem is that the R programming language’s command line interface is intimidating to many users who do not have a strong background in computing. This often leads to a situation where biologists will resort to using commercial software which often uses antiquated and much less effective statistical techniques, as well as being expensively priced. This project aims to bridge this gap by providing a user friendly web-based interface to the cutting edge statistical techniques of Bioconductor

Improving Quality of Software with Foreign Function Interfaces using Static Analysis

A Foreign Function Interface (FFI) is a mechanism that allows software written in one host programming language to directly use another foreign programming language by invoking function calls across language boundaries. Today\u27s software development often utilizes FFIs to reuse software components. Examples of such systems are the Java Development Kit (JDK), Android mobile OS, and Python packages in the Fedora LINUX operating systems. The use of FFIs, however, requires extreme care and can introduce undesired side effects that degrade software quality. In this thesis, we aim to improve several quality aspects of software composed of FFIs by applying static analysis. The thesis investigates several particular characteristics of FFIs and studies software bugs caused by the misuse of FFIs. We choose two FFIs, the Java Native Interface (JNI) and the Python/C interface, as the main subjects of this dissertation. To reduce software security vulnerabilities introduced by the JNI, we first propose definitions of new patterns of bugs caused by the improper exception handlings between Java and C. We then present the design and implement a bug finding system to uncover these bugs. To ensure software safety and reliability in multithreaded environment, we present a novel and efficient system that ensures atomicity in the JNI. Finally, to improve software performance and reliability, we design and develop a framework for finding errors in memory management in programs written with the Python/C interface. The framework is built by applying affine abstraction and affine analysis of reference-counts of Python objects. This dissertation offers a comprehensive study of FFIs and software composed of FFIs. The research findings make several contributions to the studies of static analysis and to the improvement of software quality

Object Oriented Program Correctness with OOSimL

Software reliability depends on program correctness and robustness and these are extremely important in developing high-quality software. Correctness is also essential when considering aspects of software security. However, experience applying these concepts, associated methods, and supporting software with Eiffel and Java have shown that students find some diffculty learning program correctness and in learning the software tools provided. We have developed an experimental language, OOSimL, that includes an assertion notation similar to that of Eiffel but which has much more flexibility, and that provides the same semantics as Java. The first part of this paper provides an overview of concepts and methods on software reliability then briefly describes our experience in teaching these. The second part introduces the Design by Contract (DBC) using the OOSimL programming language, which we recently developed

STATIC CODE ANALYSIS FOR SOFTWARE QUALITY IMPROVEMENT: A CASE STUDY IN BCI FRAMEWORK DEVELOPMENT

This paper shows how the systematic approach in software testing using static code analysis method can be used for improving the software quality of a BCI framework. The method is best performed during the development phase of framework programs. In the proposed approach, we evaluate several software metrics which are based on the principles of object oriented design. Since such method is depending on the underlying programming language, we describe the method in term of C++ language programming whereas the Qt platform is also currently being used. One of the most important metric is so called software complexity. Applying the software complexity calculation using both McCabe and Halstead method for the BCI framework which consists of two important types of BCI, those are SSVEP and P300, we found that there are two classes in the framework which have very complex and prone to violation of cohesion principle in OOP. The other metrics are fit the criteria of the proposed framework aspects, such as: MPC is less than 20; average complexity is around value of 5; and the maximum depth is below 10 blocks. Such variables are considered very important when further developing the BCI framework in the future