Online education comes in various flavors - skills centered short-duration training, massively open online courses (MOOCs), and more recently, the offering of full online degree programs. In the past 4 years at Arizona State University, the faculty created an online software engineering degree program equivalent to an existing on-campus program, and produced its first graduates in Spring 2017. The challenges in creating this program were significant, but surprisingly the main challenges were not the ones that the faculty anticipated at the outset of the program's development. This paper shares the lessons learned from the development of the online degree program, with an emphasis on the gap between faculty expectations and fears versus the actual issues that needed to be addressed.

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.

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 9 th 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.

In this paper, we compare the features available for developing secure distributed applications for limited devices, such as smart phones. We limit our scope to examine frameworks for Java. This work is part of a continuing project which is considering capabilities and performance for application development on these platforms. The paper considers performance as it relates to various approaches to securing applications. The paper addresses two separate concerns. First is protecting access to resources by an executing application. The facilities for defining, limiting and controlling applications during their development, installation and execution are described. Second, we discuss approaches available for securing communication among application components running on servers or limited devices.

Legacy applications are prime candidates for software reuse: they have been relied upon for several years and often have a strong organizational commitment. Migrating existing legacy applications is a very natural requirement when moving to and adopting a new technology. 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. This paper describes an architecture-based approach for the synthesis of services from legacy components and their subsequent integration with service-requesting client applications.

This paper evaluates the runtime performance of two different versions of J9 Virtual Machines (VM) on the TOSHIBA Pocket PC and the TUNGSTEN C. The publicly available benchmark and some small test programs written by the authors were tested on the devices. The VM was tested with and without Just-In-Time compiling (JIT). This paper discusses the areas where the J9 has improved performance and provides some cross platform comparisons. Also, this paper argues the reasons why benchmarks may not realize the full performance that can be achieved from the JIT enabled J9 VM and characterizes applications where the JIT will improve performance.

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.

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, SUN's 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.

We are developing a novel service-based paradigm for dynamic component integration that facilitates the creation of Intelligent Services from COTS (Commercial Off The Shelf) components, legacy components, and application frameworks by using techniques such as mediation and adaption or “wrapping”. This framework supports the construction of applications by dynamically integrating these services at run-time based on available resources and allows for a federation of services that can evolve over time. As a part of the ongoing research effort we are utilizing an architecture based specification language that enables us to automate the process of creating these intelligent services.

Today's distributed e-commerce applications typically rely upon various technologies in their realization, including the web, scripting languages, server-side processing and an underlying database. The combination of these technologies creates a system that requires attention to the security issues of each component and the system as a whole. In considering the overall system, issues arise from the interactions of security frameworks available for each component. In this paper, we consider the approach and related issues for distributed e-commerce applications developed with Java. The flexible nature of Java allows migration of objects (compiled code with state) through features such as RMI and Applets. Security for distributed applications developed in Java has issues and lessons applicable to systems of components built on different technologies.

This report summarizes the 2 nd International Workshop on Process Support for Distributed Team-based Software Development held at the Sheraton World Resort of Orlando, Florida, on July 25, 2000 in conjunction with the Information Systems, Analysis and Synthesis (ISAS2000) International Conference. An overall twenty people attended the workshop consisting of seven technical presentations in two plenary sessions. In the following, we outline the presentations and subsequent discussions, which included modeling and distributing process component, evolution and change, web-based framework, consistency management, and reuse and interoperability.The hardcopy of the papers selected for PDTSD'00 are published by the International Institute of Informatics and Systemics as a part of the " Industrial Systems " volume of ISAS 2000, ISBN 980-07-6695-2.

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

: ASU received funds on this effort to contribute to the PCIS-2 joint USA and France Technology Research and Development Project (TRDP). PCIS-2 (Portable Common Interface Set) is a three phase project whose goal is to develop a distributed software engineering environment primarily from commercial off the shelf tools, government owned tools, current distributed object technology (WWW, Java and CORBA, for example) and the technology developed in the PCIS program. Phase 1 of the project developed architecture for PCIS-2, selected a set of tools and created prototype implementation approaches. Phase 2 includes realization of the architecture and wrapping of selected tools. Phase 3 provides for usage and evaluation of the resulting environment. When software development is distributed (software engineers are geographically dispersed), cooperation among engineers in jointly producing software artifacts (source code, and associated information) becomes an important issue. The PCIS-2 Architecture includes distributed object services for software process definition and enactment, as well as services for distributed configuration management and fine grained traceability among software artifacts. These services are being realized in the PCIS-2 Phase 2, together with the wrapping of several commercial tools to utilize the services. ASU has all supported realization of the process services.

Modern automated process support systems can be considered monolithic in three ways. First, they model processes top-down, usually from a single perspective, such as the organizational perspective. Second, they are process-centered, in that they often require extensive knowledge of the users, data types, and applications in their environment. Third, they tie process implementation to a specific representation, making reuse and interoperability between process models difficult to achieve. The paper describes the application of component based techniques to process modeling across overlapping process spaces. This approach, the Open Process Components approach, encapsulates process fragments as interoperable and reusable process components. The paper motivates a vision of cooperating components for automated process support, presents an overview of the Open Process Components approach, and shows the application of this technique to W. Humphrey's (1997) Personal Software Process.

As an emerging technology, distributed software components hold promise for software interoperability, composition and reuse. This paper reports on applying distributed components as a paradigm for realizing technology enriched learning. We present a background of software components together with a framework for realizing World Wide Web-based learning components. Primarily, the web provides a data-centric interface to learning participants. An activity-centric view is more typical in object-based systems and for many learners. We show how automated support for workflow can be applied to achieve activity-based learning components on the web. One of the primary goals of the framework is that it is open to utilize various services already commonly in place in a university setting. We exemplify some of the common framework services and discuss how these can be adapted to a specific organization or extended to achieve discipline specific services.

Automated process support is the application of computer technology to assist and automate work on behalf of users. This research considers the application of automated process support in two domains, automated workflow and software process support. Common challenges face these domains. Current automated process support systems are closed in the sense there is little potential for interoperability and reuse between heterogeneous process tools. Additional requirements for handling dynamic and distributed processes also push the limits of current process technology. This research proposes a component-based framework, the Open Process Components framework, for supporting process activities: building process models, executing process models, analyzing them, and evolving them. Processes are envisioned as a set of dynamic, distributed components that interact in meaningful ways. Process components encapsulate heterogeneous implementations behind well-defined interfaces. Open Process Components is derived from common abstractions held in the process literature. These abstractions are mapped to a meta-model of the process space. From this meta-model, software abstractions are derived which form the basis of the framework. The framework is extendable to accommodate representation-specific process information while at the same time conforming to a component contract for interaction. This dissertation presents a conceptual model of a component-based process support framework, describes its realization in software, shows how a commercial process tool is integrated into the component environment, and demonstrates component-based process support on two well-known examples in the process literature.

Software engineering continues to develop methods for process improvement and quality. The personal software process is one way to introduce software engineers to aspects of process tracking, assessment and improvement. In this paper, we describe the software tools that we've constructed to support the planning and postmortem of software activities. We describe an approach that allows the personal software process to be used in group projects, while still allowing the individual engineer to employ personal process quality and improvement techniques in their own activities. The tools supporting planning and postmortems are used in the context of a workflow system developed at Arizona State University, called Open Process Components, whose aim is to componentize software services and provide interoperability among various approaches. These tools and approaches explore software development in the increasingly distributed environment in which software engineers are responsible for their own assessment and improvement.

Software is growing exponentially in complexity, cost, and size, however, the resulting software quality is declining dramatically while software development cycles continue to increase. Current approaches commonly used to address these issues are software process and automated workflows. Each realization of these concepts results in unique automated process support tools. These tools all use their own software process modeling techniques based upon their specific software meta-model. Each tool generates software process definitions that are non-composable, non-reusable, and non-interoperable. Further improvements in software development and software quality requires an approach that supports search, dynamic composition, reuse, and interoperability among these diverse software process definitions. Brokering process components provides the framework and infrastructure necessary to achieve search, dynamic composition, reuse, and interoperability among heterogeneous software process definitions. The Process Component Broker Framework accomplishes this brokering process components approach. The framework consists of three main elements: the Process Broker, the Process Component Characteristics and Controls, and Process Components. The core of the framework is the Process Broker, which provides the infrastructure and services necessary to search, dynamically compose and reuse Process Components. The process component characteristics and access controls must be exposed to the Process Broker as specified by the Process Component Characteristics and Controls. These Process Components are abstract encapsulators of the software process definitions, which are defined based on Open Process Components definition for Domain Layer process components, as well as, the common software component attributes. This dissertation presents a framework and infrastructure for brokering process components. In addition, this thesis successfully demonstrates the feasibility of this approach by implementing a simple prototype of the Process Component Broker Framework. The approach presented in this dissertation has the benefit of allowing organizations to reuse and share legacy and new software process definitions, regardless of the automated process support tools that are used to create or the location of the software process definitions. Therefore, organizations that deploy this approach can more effectively utilize software process and automated workflows to improve software development, which means shortening the development cycle time, improving software quality, and reducing development costs.

Educational World Wide Web site creation systems currently exist which either assist in generating static web sites or offer interactivity without the freedom to personalize tools or web site aesthetics. In this paper, the authors briefly review several existing systems and present a set of tools that they have developed. Their approach differs from other efforts largely in that they provide the beginnings of a component-based framework that can be extended. The tools provide components that can be used to extend an existing web site. They can also be easily configured into a web site creation tool, such as Netscape's Composer. They discuss the nature of the tools they have developed and the application of these tools to existing computer science courses.

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.