Richard S. Hall

A cooperative approach to support software deployment using the software dock

Software deployment is an evolving collection of interrelated processes such as release, install, adapt, reconfigure, update, activate, deactivate, remove, and retire. The connectivity of large networks, such as the Internet, is affecting how software deployment is performed. It is necessary to introduce new software deployment technologies that leverage this connectivity. The Software Dock framework creates a distributed, agent based deployment framework to support the ongoing cooperation and negotiation among software producers themselves and among software producers and software consumers. This deployment framework is enabled by the use of a standardized deployment schema for describing software systems, called the Deployable Software Description (DSD) format. The Software Dock also employs agents to traverse between software producers and consumers in order to perform software deployment activities by interpreting the descriptions of software systems. The Software Dock infrastructure allows software producers to offer their customers high level deployment services that were previously not possible.

Autonomous adaptation to dynamic availability using a service-oriented component model

This paper describes a project, called Gravity, that defines a component model, where components provide and require services (i.e., functionality) and all component interaction occurs via services. This approach introduces service-oriented concepts into a component model and execution environment. The goal is to support the construction and execution of component-based applications that are capable of autonomously adapting at run time due to the dynamic availability of the services provided by constituent components. In this component model the execution environment manages an application that is described as an abstract composition that can adapt and evolve at run time depending on available functionality. The motivation of Gravity is to simplify the construction of applications where dynamic availability arises, ranging from modern extensible systems to novel computing approaches, such as context-aware applications.

A case for caching file objects inside internetworks

This paper presents evidence that several, judiciously placed file caches could reduce the volume of FTP traffic by 42%, and hence the volume of all NSFNET backbone traffic by 21%. In addition, if FTP client and server software automatically compressed data, this savings could increase to 27%. We believe that a hierarchical architecture of whole file caches, modeled after the existing name servers caching architecture, could become a valuable part of any internet.We derived these conclusions by performing trace driven simulations of various file caching architectures, cache sizes, and replacement policies. We collected the traces of file transfer traffic employed in our simulations on a network that connects the NSFNET backbone to a large, regional network. This particular regional network is responsible for about 5 to 7% of NSFNET traffic.While this papers analysis and discussion focus on caching for FTP file transfer, the proposed caching architecture applies to caching objects from other internetwork services.

An architecture for post-development configuration management in a wide-area network

Few tools exist to address the post-development activities of configuring, releasing, installing, updating, reconfiguring, and even de-installing a software system. Certainly there is no unified approach for all of these activities, and none that can take full advantage of a wide-area network. The Software Dock represents an architecture for supporting post-development activities in such a setting. It is designed as a system of loosely-coupled, cooperating, distributed components that are bound together by a wide-area messaging and event system. In this paper we describe the Software Dock architecture and discuss the use of a prototype in deploying a complex system.

Software release management

Software release management begins with receipt of a release candidate comprising a software build for a particular target software release. It ends with the step of handing off that software build and associated meta-data to a manufacturing team. No changes to the software build itself are made during this process. Information about builds, targets software releases and stock keeping units (software products) are stored using a hierarchical representation. A sequence of ordered testing and approval steps is stored and may be dynamically re-configured. A release manager automatically manages the testing and approval steps according to the sequence. Web services are used to receive meta-data about the builds and release candidates.

Challenges in building service-oriented applications for OSGi

The OSGi Alliance defines and promotes open specifications for the delivery of managed services into networked environments of embedded devices. A key element of this initiative is the OSGi framework, which is a lightweight framework for deploying and executing service-oriented applications. The service-oriented approach is well suited to the dynamic environment envisioned for services gateways, but it creates unique challenges for application developers.

Programming with visual expressions

The lambda calculus is a formal symbolic term rewriting system that has been used for many years both as a mechanism for defining the semantics of programming languages and as the basis for functional programming languages. In this paper, we describe a completely visual representation for lambda expressions, VEX (Visual EXpressions), that has several advantages over traditional textual lambda calculus. Although VEX is designed as an expression-oriented component of VIPR (VIsual PRogramming language), it can also be used in teaching the concepts of the lambda calculus as a replacement for or augmentation to the teaching of traditional textual rewrite rules. Many semantic issues in the lambda calculus that are confusing to students, including substitution, free variables and binding, become apparent and explicit in VEX.

A Framework for Constructing Adaptive Component-Based Applications: Concepts and Experiences

This paper describes the experience of building component-oriented applications with a framework that supports run-time adaptation in response to the dynamic availability of functionality provided by constituent components. The framework’s approach is to define a service-oriented component model, which is a component model that includes concepts from service orientation and an execution environment that provides automatic adaptation mechanisms. This paper focuses on an example scenario and two real-wold examples where this framework has been used.

A Policy-Driven Class Loader to Support Deployment in Extensible Frameworks

The simplicity of dynamic code loading in Java has led to the increased popularity of extensible frameworks, where additional functionality is incorporated into a system at run time. These extensible frameworks take on many forms, such as component frameworks, plugin mechanisms, and programming environments. An interesting aspect of extensible frameworks is that they extend the software deployment life cycle down to the individual process or virtual machine level. This paper discusses how to generically support deployment for extensible frameworks and, in particular, presents a policy-driven class loader for simplifying the activation deployment process for Java-based extensible frameworks.

A framework for analyzing configurations of deployable software systems

Configuring and deploying a large software system is complicated when the system is composed of components and when there are numerous possible configurations for the system. In such a scenario, it is difficult for end users to specify and install an appropriate configuration for their specific environment. Defining all valid configurations of a software system is challenging, and can be addressed through a concise specification that can generate all of the possible configurations. The Deployable Software Description (DSD) part of the University of Colorado Software Dock project, is one such specification format. But using the DSD runs the risk that the set of generated configurations includes some that are invalid with respect to constraints defined independently of the DSD. The paper describes a framework to support the analysis of DSD specifications to help developers detect potentially invalid configurations. This analysis assumes that the system components are annotated with properties, and an analysis tool is provided that takes a specific configuration and analyzes it for conflicts with respect to some set of constraints. Using the DSD, we can enumerate and analyze configurations to verify their validity. The results can be used to modify the DSD to avoid future generation of invalid configurations.