Timothy E. Lindquist

An architecture-based approach for synthesizing and integrating adapters for legacy software

In software organizations there is a very real possibility that a commitment to existing assets will require migration of legacy software towards new environments that use modern technology. One technique that has been suggested for facilitating the migration of existing legacy assets to new platforms is via the use of the adapter design pattern, also known as component wrapping. We describe an approach for facilitating the integration of legacy software into new applications using component wrapping. That is, we demonstrate the use of a software architecture description language as a means for specifying various properties that can be used to assist in the construction of wrappers. In addition, we show how these wrapped components can be used within a distributed object infrastructure as services that are dynamically integrated at runtime.

A Java cryptography service provider implementing one-time pad

Security is a challenging aspect of communications today that touches many areas including memory space, processing speed, code development and maintenance issues. When it comes to dealing with lightweight computing devices, each of these problems is amplified. In an attempt to address some of these problems, Suns Java 2 standard edition version 1.4 includes the Java cryptography architecture (JCA). The JCA provides a single encryption API for application developers within a framework where multiple service providers may implement different algorithms. To the extent possible application developers have available multiple encryption technologies through a framework of common classes, interfaces and methods. The one time pad encryption method is a simple and reliable cryptographic algorithm whose characteristics make it attractive for communication with limited computing devices. The major difficulty of the one-time pad is key distribution. In this paper, we present an implementation of one-time pad as a JCA service provider, and demonstrate its usefulness on Palm devices.

Android and ODK based data collection framework to aid in epidemiological analysis

Periodic collection of field data, analysis and interpretation of data are key to a good healthcare service. This data is used by the subsequent decision makers to recognize preventive measures, provide timely support to the affected and to help measure the effects of their interventions. While the resources required for good disease surveillance and proactive healthcare are available more readily in developed countries, the lack of these in developing countries may compromise the quality of service provided. This combined with the critical nature of some diseases makes this an essential issue to be addressed. Taking advantage of the rapid growth of cell phone usage and related infrastructure in developed as well as developing countries, several systems have been established to address the gaps in data collection. Android, being an open sourced platform, has gained considerable popularity in this aspect. Open data kit is one such tool developed to aid in data collection. The aim of this paper is to present a prototype framework built using few such existing tools and technologies to address data collection for seasonal influenza, commonly referred to as the flu.

Test-case generation with IOGen

The IOGen static-analysis tool for a subset of Ada addresses part of the problem of verification of software reliability. It uses a technique based on symbolic execution and produces a set of I/O pairs that represent execution paths through a program. The authors present IOGens design and demonstrate how to use it to test programs and validate Ada software interfaces. Although IOGen is specific to an Ada subset, the same technique can be applied to any language with a grammar that uses a left-to-right scan with one look-ahead token producing a leftmost derivation (an LL(1) grammar).<<ETX>>

Synthesizing and integrating legacy components as services using adapters

In 1971, C.A.R. Hoare gave the proof of correctness and termination of a rather complex algorithm, in a paper entitled Proof of a program: Find. It is a handmade proof, where the program is given together with its formal specification and where each step is fully justified by mathematical reasoning. We present here a formal proof of the same program in the system Coq, using the recent tactic of the system developed to establish the total correctness of imperative programs. We follow Hoare’s paper as closely as possible, keeping the same program and the same specification. We show that we get exactly the same proof obligations, which are proved in a straightforward way, following the original paper. We also explain how more informal aspects of Hoare’s proof are formalized in the system Coq. This demonstrates the adequacy of the system Coq in the process of certifying imperative programs. c

Automated process support for organizational and personal processes

We propose two views on process: an organizational view and a personal process view. Information technology applies Automated Workflow technology to define, execute, and track an organization’s automated business processes. Calendaring tools provide a form of personal process view through scheduled work items. However, the personal, or individual, view of the process space has largely been ignored. We maintain that as organizations become increasingly decentralized, a single organization’s process space is becoming difficult to recognize. Individuals of the organization are asked to do work that spans organizational, functional, and even geographic boundaries. An integrated view of organizational workflows and personal processes is needed to address these new demands. In this paper we argue for the need to integrate organizational and personal processes. We then propose a component-based process modeling approach and supporting process architecture that integrates these process spaces. Finally, we describe our recent efforts at developing Java prototype process tools that realize the proposed modeling technique and supporting architecture.

Automated support for service-based software development and integration

Abstract A service-based development paradigm is one in which components are viewed as services. In this model, services interact and can be providers or consumers of data and behavior. Applications in this paradigm dynamically integrate services at runtime-based on available resources. This paper describes an architecture-based approach for the creation of services and their subsequent integration with service-requesting client applications.

Component-based software process support

Only recently has the research community started to consider how to make software process models interoperable and reusable. The task is difficult Software processes are inherently creative and dynamic difficult to define and repeat at an enactable level of detail. Additionally, interoperability and reusability have not been considered important issues. Recent interoperability and reusability solutions advocate the development of standard process model representations based on common concepts or generic schemas, which are used as a basis for translating between heterogeneous process representations. The authors propose an alternative approach through the development of process-based components. They present the Open Process Components Framework, a component based framework for software process modeling. In this approach, process models are constructed as sets of components which interact in meaningful ways. Interoperability and reuse are obtained through encapsulation of process representations, an explicit representation of process state, and an extendable set of class relationships.

Towards target-level testing and debugging tools for embedded software

The current process for testing and debugging embedded sojware is ine~ective at revealing errors. There are currently huge costs associated with the validation of embedded applications. Despite the huge costs, the most dl~cult errors to reveal and locate are found extremely late in the testing process, making them even more costly to repm”r. This paper first presents a discussion of embedded testing research andpractice. This discussion raises a need to improve the existing process and tools for embe&@i testing as well as enable better processes and tools for the jWure. To fmilitate this improvement, architectural and software capabilities which support testing and &bugging with minimal intrusion on the executing system must be developed. Execution visibility and control must come @om the underlying system, which should ofJer interjbces to testing and debugging tools in the same numner it offers them to a compiler. Finally we propose txtenswns to the underlying system, which consists of adiiitions to both the architecture and run-time system that will help reulize target-level tools.

A project spine for software engineering curricular design

Software engineering education is a technologically challenging, rapidly evolving discipline. Like all STEM educators, software engineering educators are bombarded with a constant stream of new tools and techniques (MOOCs! Active learning! Inverted classrooms!) while under national pressure to produce outstanding STEM graduates. Software engineering educators are also pressured on the discipline side; a constant evolution of technology coupled with a still emerging engineering discipline. As a handson engineering discipline, where engineers not only design but also construct the technology, guidance on the adoption of project-centric curricula is needed. This paper focuses on vertical integration of project experiences in undergraduate software engineering degree programs or course sequences. The Software Enterprise, now in its 9th year, has grown from an upper-division course sequence to a vertical integration program feature. The Software Enterprise is presented as an implementation of a project spine curricular pattern, and a plan for maturing this model is given.