Johannes Sametinger

Software engineering with reusable components

The book provides a clear understanding of what software reuse is, where the problems are, what benefits to expect, the activities, and its different forms. The reader is also given an overview of what sofware components are, different kinds of components and compositions, a taxonomy thereof, and examples of successful component reuse. An introduction to software engineering and software process models is also provided.

Security challenges for medical devices

Implantable devices, often dependent on software, save countless lives. But how secure are they?

Secure and usable authentication on mobile devices

Mobile devices contain a multitude of sensitive data and provide access to even more data as well as services somewhere on the Internet. Even if only temporarily in the hands of non-entitled persons, privacy is at stake. Authentication protects against unauthorized usage. Todays operating systems of mobile devices offer authentication mechanisms. However, they are either vulnerable in some situations or not user friendly enough to be widely adopted. In this paper we suggest a novel authentication system which meets both the requirements of security and usability. For that purpose, we have analyzed existing authentication methods as well as targeting attacks. The resulting Android application SecureLock is a generic authentication system, which offers PIN and password, but also a property-based authentication method by means of NFC tags, and a novel image-based method called GesturePuzzle. The application has been evaluated and compared with other approaches for security and usability.

Object-oriented documentation

Object-oriented programming improves the reusability of software components. Extensive reuse of existing software enhances the importance of documentation. To increase productivity in documenting and to make the structure of documentation better suitable for object-oriented software systems, we suggest applying object-oriented technology to the documentation, too. This makes it possible to reuse documentation by extending and modifying it without making copies and without making any changes to the original documentation. Additionally, interests of various groups of readers (for example, reusers and maintenance staff) can be taken into account, and easy access to relevant information can be given.In this paper, we briefly describe a documentation scheme for object-oriented software systems. This scheme distinguishes among overview, external view, and internal view of both static and dynamic aspects of software components. Then we apply inheritance by simply reusing and extending existing documentation where appropriate, and enforce information hiding by providing an access control mechanism. This improves the reusability and accessibility of documentation. Additionally, we present an exemplary tool and relate our experience with object-oriented documentation.

Evolution support by homogeneously documenting patterns, aspects and traces

The evolution of complex software systems is promoted by software engineering principles and techniques like separation of concerns, encapsulation, stepwise refinement, and reusability of design solutions. Design patterns capture the expertise for reusable design solutions. Aspect-oriented programming is a methodology that enables the modularization of cross-cutting concerns. Traceability links designate dependencies between requirements, design, and source code. In order to support maintenance, documentation has to enable understandability by describing these issues. Descriptions have to facilitate tool support for automating documentation activities. In this paper, we use the notion of patterns, aspects and traces for a homogeneous documentation approach. We integrate various types of documentation, keep track of traces from requirements to the source code, keep design information in the source code, and generate additional design views on software systems. We have implemented these ideas as an extension to javadoc, the documentation approach used by Java. This extension can be used to automatically generate views on the design and on aspects as well as on traceability links as part of the standard javadoc system documentation.

A tool for the maintenance of C++ programs

The author describes a software tool that helps programmers understand object-oriented software systems written in C++. This task is accomplished by providing information about the set of classes and files of which the system is comprised and the relationships among them. The tool described enables its users to browse easily through the system on the basis of the relations among its classes, files, and even identifiers. In addition, the flexible use of global text styles enhances the readability of the source code. The implementation of the tool is described. In particular, problems are mentioned that arise when performing static analysis of C++ programs.<<ETX>>

Security in Open Source Web Content Management Systems

Typically, users of Web content management systems lack expert knowledge of the technology itself, let alone the security issues therein. Complicating the matter, WCMS vulnerabilities are attractive targets for potential attackers. A security analysis of two popular, open-source WCMSs exposed significant security holes, despite the obvious efforts of their developer communities. These vulnerabilities leave the applications and their nonexpert users open to exploitation.

Concepts and architecture of a simulation framework based on the JavaBeans component model

Abstract We report on a combination of system theoretic simulation modeling methodology with the JavaBeans component model as a basis for a component-based simulation framework. While system theory formalisms can serve as formal, mathematical foundations for modular, hierarchical modeling and simulation, the JavaBeans component model provides the appropriate implementation base. The result of the synergism is a powerful component-based simulation framework. In this paper we present the basic concepts and overall architecture of our JavaBeans modeling and simulation framework. We review the underlying system modeling formalisms for simulation modeling, sketch the layered architecture of the framework, and show elementary simulation programming and interface-based, hierarchical coupling of simulation components in more detail. Finally, we show the current state of implementation and demonstrate how simulation models can be developed using standard bean builder tools.

Literate programming and documentation reuse

Object-oriented programming has brought many advantages to the software engineering community. The reuse of existing software components and application frameworks can improve the productivity in software development considerably. The same object-oriented techniques, i.e., inheritance and information hiding, that ease reusing software, can be applied to documentation and thus, enable its reuse. One can document each software component-regardless of what a component is-from scratch. This leads to multiple documentation of features that are multiply reused. One can also describe a components differences to other components. This seems logical for the systems documentation of object-oriented software. However, as is shown, this kind of reuse can not only be applied to source-code related documentation, but also to documentation, where there is no source code involved at all, e.g., user documentation. We describe the concepts for documentation reuse, how these concepts can be realized with a literate programming tool, and the application of documentation reuse.

User-adaptable prettyprinting

This paper presents a prettyprinter for high‐level languages that can be adapted to the personal preferences of an individual user or to particular project conventions. The customization of the prettyprinter is done by means of a user profile with a set of parameters. The available parameters have been chosen with respect to minimality of the user interface and reasonable flexibility. The paper includes a complete list of all parameters with examples. The prettyprinter is fairly portable; it consists of a language‐independent back end and a front end that is created by a compiler generator from a formal description of the language to be processed. Currently, Modula‐2 and Pascal versions of the prettyprinter have been implemented.