Assertions are a crucial aspect of software development, serving as a way to validate conditions during code execution. They are expressed as Boolean expressions that must hold true for the code to run correctly and enforce design decisions and constraints. This paper introduces a new approach for creating assertions called design assertions. These assertions are generated from formally written design constraints and help to enforce important design decisions during code execution. The approach utilizes immutable library classes, specifically designed for writing design assertions, and converts design constraints written in the Object Constraint Language (OCL) into assert statements in the Dart language. The result is a more readable, maintainable, and reliable set of Dart assertions, providing a powerful tool for ensuring software design quality and integrity.

Java and Android applications can be written in the same programming language. Thus, it is natural to ask how much code can be shared between them. In this paper, we perform a case study to measure quantitatively the amount of code that can be shared and reused for a multiplatform application running on the Java platform and the Android platform. We first configure a development environment consisting of platform-specific tools and supporting continuous integration. We then propose a general architecture for a multiplatform application under a guiding design principle of having clearly defined interfaces and employing loose coupling to accommodate platform differences and variations. Specifically, we separate our application into two parts, a platform-independent part (PIP) and a platform-dependent part (PDP), and share the PIP between platform-specific versions. Our key finding is that 37%--40% of code can be shared and reused between the Java and the Android versions of our application. Interestingly, the Android version requires 8% more code than Java due to platform-specific constraints and concerns. We also learned that the quality of an application can be improved dramatically through multiplatform development.

Software developers of today are under increasing pressure to support multiple platforms, in particular mobile platforms. However, developing a multiplatform application is difficult and challenging due to a variety of platform differences. We propose a native approach for developing a multiplatform application running on two similar but different platforms, Java and Android. We address practical software engineering concerns attributed to native multiplatform application development, from configuration of tools to software design and development process. Our approach allows one to share 37%~40% of application code between the two platforms as well as improving the quality of the application. We believe our approach can also be adapted to transforming existing Java applications to Android applications.

In evolutionary testing of an object-oriented program, the search objective is to find a sequence of method calls that can successfully produce a test object of an interesting state. This is challenging because not all call sequences are feasible; each call of a sequence has to meet the assumption of the called method. The effectiveness of an evolutionary testing thus depends in part on the quality of the so-called fitness function that determines the degree of the fitness of a candidate solution. In this paper, we propose a new fitness function based on assertions such as method preconditions to find feasible sequences of method calls. We show through experiments that to obtain the best search result the fitness function should consider the structures of method call sequences, which are essentially trees of assertions. We also provide a framework for combining multiple fitness values and for analyzing different fitness functions.

Encapsulation of states in object-oriented programs hinders the search for test data using evolutionary testing. As client code is oblivious to the internal state of a server object, no guidance is available to test the client code using evolutionary testing; i.e., it is difficult to determine the fitness or goodness of test data, as it may depend on the hidden internal state. Nevertheless, evolutionary testing is a promising new approach of which effectiveness has been shown by several researchers. We propose a specification-based fitness function for evolutionary testing of object-oriented programs. Our approach is modular in that fitness value calculation doesn't depend on source code of server classes, thus it works even if the server implementation is changed or no code is available----which is frequently the case for reusable object-oriented class libraries and frameworks.

This paper presents initial research on unification of methods for verification and validation (V&V) of software systems. The synergism among methods for V&V are described. The requirements for a unification are defined. The initial steps of a case study of application of the unified approach to V&V is sketched including definition of the problem domain, the approach and some details of a property specification language. An undergraduate course introducing the unified approach to V&V is described. The relationship of this research to other efforts toward unification of V&V are discussed.

In design by contract (DBC), assertions are typically written using program variables and query methods. The lack of separation between program code and assertions is confusing, because readers do not know what code is intended for use in the program and what code is only intended for specification purposes. This lack of separation also creates a potential runtime performance penalty, even when runtime assertion checks are disabled, due to both the increased memory footprint of the program and the execution of code maintaining that part of the program's state intended for use in specifications. To solve these problems, we present a new way of writing and checking DBC assertions without directly referring to concrete program states, using ‘model’, i.e. specification-only, variables and methods. The use of model variables and methods does not incur the problems mentioned above, but it also allow one to write more easily assertions that are abstract, concise, and independent of representation details, and hence more readable and maintainable. We implemented these features in the runtime assertion checker for the Java Modeling Language (JML), but the approach could also be implemented in other DBC tools. Copyright © 2005 John Wiley & Sons, Ltd.

The ability to treat code as data within a programming language is a powerful feature. Smalltalk introduces an object called a block that represents code as data. We propose a formal description technique to specify the behavior of Smalltalk blocks. The traditional Hoare-style pre- and postcondition technique is extended to incorporate two new predicate composition operators called a sequence operator and a sequential quantifier. The sequence operator combines two predicates by identifying the post-state of the first predicate and the pre-state of the second predicate. The sequential quantifier is an extension of sequence operator to a sequence of predicates. We illustrate our approach by using Smalltalk blocks, but the approach is not in any way Smalltalk specific. It can be applied to closures in other programming languages.

Object-oriented programming languages, such as Smalltalk, help one to build reusable program modules. The reuse of program modules requires adequate documentation --- formal or informal. Larch/Smalltalk is a formal specification language for specifying such reusable Smalltalk modules. Larch/Smalltalk firmly separates specification from implementation. In Larch/Smalltalk, the unit of specification is an abstract data type, which is an abstraction of the behavior produced by one or more Smalltalk classes. A type can be a subtype of other types, which allows types to be organized based on specified behavior, and also allows for inheritance of their specifications. Larch/Smalltalk specifications are developed using specification tools integrated in the Smalltalk programming environment.