Showing papers on "Application software published in 1997"

Downloading applications software through a broadcast channel

Abstract: Set-top terminals utilized in broadband broadcast networks are becoming increasingly intelligent (programmable). However, transmitting executable code, data and interactive audio/video materials through a selectively dedicated link requires an extensive, broadband point-to-point broadband network, which is prohibitively expensive to implement for large numbers of customers. The present invention provides for downloading application software and transmitting audio/video information through one channel of a digital broadcast network. The network also provides two-way, low-speed data communications capacity, e.g. for signaling and/or interactive text services. Signaling via data communication with a text server controls downloading of executable code from the digital broadcast channel into a programmable digital set-top terminal. Execution of the downloaded code in turn controls selective capture and presentation of audio and video segments received over one of the digital broadcast channels. Resident operating system and application software in the terminal provides all communication with nodes of the network. The downloaded code forms a non-resident application having a set of predetermined function calls for activating communication functions of the resident software.

Model-integrated computing

Abstract: Computers now control many critical systems in our lives, from the brakes on our cars to the avionics control systems on planes. Such computers wed physical systems to software, tightly integrating the two and generating complex component interactions unknown in earlier systems. Thus, it is imperative that we construct software and its associated physical system so they can evolve together. The paper discusses one approach that accomplishes this called model-integrated computing. This works by extending the scope and use of models. It starts by defining the computational processes that a system must perform and develops models that become the backbone for the development of computer-based systems. In this approach, integrated, multiple-view models capture information relevant to the system under design. The paper considers the Multigraph Architecture framework for model-integrated computing developed at Vanderbilt's Measurement and Computing Systems Laboratory.

Scheduling real-time applications in an open environment

Abstract: This paper extends the two-level hierarchical scheme in (Deng et al., 1997) for scheduling independently developed real-time applications with non-real-time applications in an open environment. The environment allows the schedulability of each real-time application to be validated independently of other applications in the system. The extended scheme removes the following two restrictions of the scheme: real-time applications that are scheduled preemptively must consist solely of periodic tasks; and applications must not share global resources (i.e., resources used by more than one application). Consequently, the extended scheme can accommodate a much broader spectrum of real-time applications.

Designing distributed applications with mobile code paradigms

Abstract: Large scale distributed systems are becoming of paramount importance, due to the evolution of technology and to the interest of market. Their development, however, is not yet supported by a sound teclmological and methodological background, as the results developed for small size distributed systems often do not scale up. Recently, mobile code languages (MCLs) have been proposed as a technological answer to the problem. In this work, -we abstract away from the details of these languages by deriving design paradigms exploiting code mobility that are independent of any particular technology. We present such design paradigms, together with a discussion of their features, their application domain, and some hints about the selection of the correct paradigm for a given distributed application.

Design of dynamically reconfigurable real-time software using port-based objects

Abstract: The port-based object is a new software abstraction for designing and implementing dynamically reconfigurable real-time software. It forms the basis of a programming model that uses domain-specific elemental units to provide specific, yet flexible, guidelines to control engineers for creating and integrating software components. We use a port-based object abstraction, based on combining the notion of an object with the port-automaton algebraic model of concurrent processes. It is supported by an implementation using domain-specific communication mechanisms and templates that have been incorporated into the Chimera real-time operating system and applied to several robotic applications. This paper describes the port-based object abstraction, provides a detailed analysis of communication and synchronization based on distributed shared memory, and describes a programming paradigm based on a framework process and code templates for quickly implementing applications.

Acquisition and operation of remotely loaded software using applet modification of browser software

Abstract: Methods, systems, and software for installing and operating selected software applications on a client computer that is in communication with a server computer on a computer network is described. In one aspect, a method for installing and operating a selected software application on a client computer that is in communication with a server computer across a computer network. In one embodiment, browser software is provided on the client computer that includes a browser user interface and is effective to identify and download selected software applications from the server onto the client computer for execution thereby. A data transfer communication link is established between the client and server computers across the network, a desired software application is selected using the browser, and the desired software application is transmitted across the network from the server to the client. The browser user interface is then transmuted into the user interface of the desired application to allow operation of the downloaded software application using the transmuted browser user interface. Using the methods, systems, and software described herein, software can be distributed to client computers without the installation and other management difficulties common with managing software on multiple computer systems. More importantly, the methods, systems, and apparatus provided by the present invention allow for the distribution of software that is platform-independent; thereby freeing network and system administrators--and users--from the frustrations and difficulties created by the need to manage various platform-dependent versions of software.

Performance analysis of embedded software using implicit path enumeration

Abstract: Embedded computer systems are characterized by the presence of a processor running application-specific dedicated software. A large number of these systems must satisfy real-time constraints. This paper examines the problem of determining the extreme (best and worst) case bounds on the running time of a given program on a given processor. This has several applications in the design of embedded systems with real-time constraints. An important aspect of this problem is determining which paths in the program are exercised in the extreme cases. The state-of-the-art solution here relies on an explicit enumeration of program paths. This solution runs out of steam rather quickly since the number of feasible program paths is typically exponential in the size of the program. We present a solution for this problem that does not require an explicit enumeration of program paths, i.e., the paths are considered implicitly. This solution is implemented in the program cinderella (in recognition of her hard real-time constraint-she had to be back home at the stroke of midnight), which currently targets a popular embedded processor-the Intel i960. The preliminary results of using this tool are also presented here.

Server-side asynchronous form management

Abstract: Methods, systems and computer program products which provide for communicating with a web browser executing on a remote/mobile processing system which is temporarily and intermittently connected to a second computer by storing in a persistent request queue at the second computer, a request from the web browser to a server application accessible to the second computer. Also disclosed are methods, systems and computer program products which allow for operation and management of asynchronous operations of a web browser where the operations are carried out by a server-side intercept module.

Web browser control for incorporating web browser functionality into application programs

Abstract: A web browser control allows application program developers to incorporate web browser functionality into application programs. The web browser control exposes web browsing functionality to application programs through an application program interface. This interface comprises member functions, events and properties. The member functions provide high level services such as Navigate to a URL, go forward or backward in a navigation stack, or refresh the display of an HTML page. The events are notification messages that the control sends to a host application to notify the application about actions that have taken place or are about to take place. The properties provide status information about an instance of a control. A host application can create several instances of the web browser control and communicate with them through the interface on each instance.

Application of neural networks to software quality modeling of a very large telecommunications system

Abstract: Society relies on telecommunications to such an extent that telecommunications software must have high reliability. Enhanced measurement for early risk assessment of latent defects (EMERALD) is a joint project of Nortel and Bell Canada for improving the reliability of telecommunications software products. This paper reports a case study of neural-network modeling techniques developed for the EMERALD system. The resulting neural network is currently in the prototype testing phase at Nortel. Neural-network models can be used to identify fault-prone modules for extra attention early in development, and thus reduce the risk of operational problems with those modules. We modeled a subset of modules representing over seven million lines of code from a very large telecommunications software system. The set consisted of those modules reused with changes from the previous release. The dependent variable was membership in the class of fault-prone modules. The independent variables were principal components of nine measures of software design attributes. We compared the neural-network model with a nonparametric discriminant model and found the neural-network model had better predictive accuracy.

Seeking solutions in configurable computing

Abstract: Configurable computing offers the potential of producing powerful new computing systems. Will current research overcome the dearth of commercial applicability to make such systems a reality? Unfortunately, no system to date has yet proven attractive or competitive enough to establish a commercial presence. We believe that ample opportunity exists for work in a broad range of areas. In particular, the configurable computing community should focus on refining the emerging architectures, producing more effective software/hardware APIs, better tools for application development that incorporate the models of hardware reconfiguration, and effective benchmarking strategies.

Interface layer for navigation system

Abstract: An improved method and system that provides for a data access interface layer in a navigation system. The navigation system is of the type that includes a navigation application software program that provides navigating features to a user of the system and a geographic database stored on a computer-readable storage medium wherein the geographical database includes information relating to the geographical region about which the navigation system provides the navigation features to the user. The data access interface layer is preferably stored in the navigation system as a library of software functions. The data access interface layer operates in conjunction with the navigation system application software. The data access interface layer isolates the navigation application software from the geographic data which are stored on the storage medium. The data access interface layer intercepts requests by the navigation application software for geographic data. The data access interface layer retrieves geographic data from the storage medium and converts the data into a format usable by the navigation application software. The data access interface layer also provides for memory management that facilitates accessing and using geographic data from the particular storage medium quickly and efficiently. By recognizing that different media types have different physical formats, the data access interface layer accommodates and isolates the differences so that the portions of the data access interface layer that interact with the navigation application software can be generic.

Storing and retrieving software components: a refinement based system

Abstract: Software libraries are repositories which contain software components; as such, they represent a precious resource for the software engineer. As software libraries grow in size, it becomes increasingly difficult to maintain adequate precision and recall with informal retrieval algorithms. In this paper, we discuss the design and implementation of a storage and retrieval structure for software components that is based on formal specifications and on the refinement ordering between specifications.

Computerized system for the design, execution, and tracking of exercise programs

Abstract: A computerized system and method for the design, execution and tracking of exercise programs including portable microprocessor controlled data controllers to instruct and record the actual computed workout for the user. A data communication link transfers data between the data controllers and a computer hosting application software and database files for the particular user, exercise and exercise regimen to create and display a customizable and comprehensive exercise system designed for the particular user.

Method and system for custom computer software installation

Abstract: A method and system for custom computer software installation using a standard rule-based installation engine is disclosed. Custom installation parameters are translated into a simplified script language file by a system administrator. An application software package is installed onto a computer using the standard rule-based installation engine, which is executed normally according to commands stored in a rule-based instruction file. The rule-based instruction file has been configured by the provider of the application software package to cause the rule-based installation engine to execute commands according to the simplified script language file. In this manner, the system administrator may achieve flexibility and control over each phase of the software installation process without being required to have a knowledge of the specific language of the rule-based instruction file.

A dynamic reconfiguration run-time system

Abstract: The feasibility of run-time reconfiguration of FPGAs has been established by a large number of case studies. However, these systems have typically involved an ad hoc combination of hardware and software. The software that manages the dynamic reconfiguration is typically specialised to one application and one hardware configuration. We present three different applications of dynamic reconfiguration, based on research activities at Glasgow University, and extract a set of common requirements. We present the design of an extensible run-time system for managing the dynamic reconfiguration of FPGAs, motivated by these requirements. The system is called RAGE, and incorporates operating-system style services that permit sophisticated and high level operations on circuits.

Visual composition tool for constructing application programs using distributed objects on a distributed object network

Abstract: A method, apparatus, and program code visually constructs object-oriented application software to be installed on a distributed object system. The method of the invention includes the following steps. Initially, the method provides a catalog facility which contains components having references to pre-existing objects within a distributed object system. A component is selected from the catalog facility for inclusion in the application software. A part corresponding to the object referenced by the selected component is derived from the selected component. The part is then made available to an application construction environment. In this environment, the part can be linked to at least one other part that also references a pre-existing object in the distributed object system. Graphical facilities are provided within the application construction environment for selecting and defining links among parts. Links define relationships between parts and thereby provide computer code for the application software under construction. When the part is linked to another part in the application construction environment, computer code is generated that will be effective to implement the relationship between the parts when the application program is run.

Secure on-line PC postage metering system

Abstract: The present invention is a system for providing secure access and execution of application software stored on a first computer by a second computer using a communication device while a communication link is maintained between the first and second computers. More specifically, the present invention is a secure software rental system. The system enables a user in a remote location using a personal computer and a modem to connect to a central rental facility, transfer application software from the central rental facility to the remote computer, and execute the application software on the remote computer while electronically connected to the central rental facility. When the communication link between the central rental facility and the remote computer is interrupted or terminated, the application software no longer executes on the remote computer. The application software stored on the central rental facility is integrated with the header software to provide a security feature of the present invention. The use of header software allows the user to execute the application software only while the user is electronically connected to the central rental facility continuously. In one embodiment, the rental software is an on-line postage metering program. In this embodiment, a user computer and a user printer, electronically connected to the PSD server and the USPS computer, constitute an on-line electronic postage meter. The on-line electronic postage meter allows a remote user to print postage using a local printer in a secure manner. A printed postage appears as a two-dimensional bar-code that includes a unique serial number, mail delivery point information, and the amount of postage.

Trusting mobile user devices and security modules

Abstract: The market for devices like mobile phones, multifunctional watches, and personal digital assistants is growing rapidly. Most of these mobile user devices need security for their prospective electronic commerce applications. While new technology has simplified many business and personal transactions, it has also opened the door to high-tech crime. We investigate design options for mobile user devices that are used in legally significant applications.

Software processes are software too, revisited: an invited talk on the most influential paper of ICSE 9

Abstract: The ICSE 9 paper, “Software Processes are Software Too”’ suggests that software processes are themselves a form of software and that there are considerable benefits that will derive from basing a discipline of software process development on the more traditional discipline of application software development. This paper attempts to clarify some misconceptions about this original ICSE 9 suggestion and summarizes some research carried out over the past ten years that seems to confirm the original suggestion. The paper then goes on to map out some future research directions that seem indicated. The paper closes with some ruminations about the significance of the controversy that has continued to surround this work. Introduction “Software Processes are Software Too.” How many times I have heard that phrase quoted back to me in the past ten years! And how many times it has been (sometimes amusingly) misquoted too. Often I have been flattered to have had the ICSES paper [15] and its catchy title referred to as being “classic” and “seminal”. But often I have also been asked, “what does that really mean?” The idea is, alas, still misunderstood and misconstrued in some quarters. But amazingly, and gratifyingly, the phrase is still used, and the discussion of the idea still continues, even after ten years. The suggestion that software, and the processes that deal with it, might somehow be conceptually similar remains a powerfully appealing one that seems to have *This work was supported in part by the Air Force Materiel Command, Rome Laboratory, and the Defense Advanced Research Projects Agency under Contract F3060294-C0137. permission to &ke digitafiard copies of all or part ofthis mate&l for perSonal or classroom use is granted without fee provided that the copies we not made or distributed for profit or commercial advantage, the copy@bt notice, the title ofthe publication and its date appear, and notice is &‘a that copyright is by permission oftbe ACM, Inc. To copy otherwise, to republish, to post on servers or to redistribute to lists, requires specific permission and/or fee ICSE 97 Boston MA USA Copyright 1997 ACM 0-89791-914-9/97/05 ..$3.50 led to a considerable body of investigation, The suggestion was immediately controversial, and continues to be argued. Subsequently I discuss why I believe this discussion indicates a pattern of behavior typical of traditional scientific inquiry, and therefore seems to me to do credit to the software engineering community. But what of the (in)famous assertion itself? What does it really mean, and is it really valid? The assertion grew out of ruminations about the importance of orderly and systematic processes as the basis for assuring the quality of products and improving productivity in developing them. Applying the discipline of orderly process to software was not original with me. Lehman [13] and other8 [18] had suggested this long before. But I was troubled because I had started to see the development of a whole new discipline and technology around the idea of software process, and to notice the emergence of many notions and tools that seemed eerily familiar. I was starting to see the creation of a software process universe parallel to the universe of notions and tools surrounding application software development. The more I looked, the more similarities I saw. Processes and applications are both executed, they both address requirements that need to be understood, both benefit from being modelled by a variety of sorts of models, both must evolve guided by measurement, and so forth. Thus it seemed important to suggest that software process technology might not need to be invented from scratch (or reinvented), but that much of it might be borrowed from application software technology. I have often been reminded that application software technology is still badly underdeveloped and that using it as a model for software process technology might be of dubious value. This, however, overlooks clear evidence that, while we have not mastered application software technology, we have, nevertheless, created a powerful assortment of tools, principles, and techniques in this domain. Thus, there is much to be gained from using obvious parallels to hasten the maturation of software process technology. It seemed important to suggest that the community should look to the more traditional and better-developed disciplines of application development to see what might be borrowed or adapted. It seemed clear that there were strong similarities, but likely that there were differences as well. Investigation of the extent of each seemed to be in order. The ICSE 9 talk invited community investigation of how processes and application software are the same and how they differ, so that relevant findings, approaches, and tools of one could be of use to the other. It has been gratifying to see that this invitation has been taken up and that these explorations are still ongoing. Conversely it has been disappointing to see the way in which the suggestion has continued to be misconstrued in some quarters. Subsequent sections will deal with these misconceptions in more detail, but the following brief summary seems in order here. Software is not simply code. Neither are software processes. Application software generally contains code. This suggests that software processes might also contain code. Coding software processes thus seems to be an interesting possibility. Research has borne this out. Programming is not the same as coding, it entails the many diverse steps of software development. Software process programming should, likewise, not simply be coding, but seemed to entail the many non-coding steps usually associated with application development. Process modelling, testing, and evolution research seems to have borne that out. There are many examples of application code that are not inordinately prescriptive, authoritarian, or intolerable to humans (eg. operating systems). Thus, there should be no presumption that process code must be overly prescriptive, authoritarian, or intolerable either. Process programs need not treat humans like robotsunless that is the intention of the process programmer. Process modellmg and coding languages demonstrate this. Finally, good software code is written at all levels of detail. Code contains fine scale details, but they emerge at lower levels, after high level code addresses larger issues. Similarly process code contains details that are nested below higher abstract levels. Process code, like application code, can demonstrate that precise implementation of broader notions in terms of lower level engineering details. Contemporary process coding languages demonstrate this too. The following section summarizes some research that suggests continued and broadened research into these issues. Parallels Between Software Processes and Appli-

Client-side asynchronous form management

Abstract: Methods, systems and computer program products are provided for communicating with a web browser executing on a remote/mobile processing system which is temporarily and intermittently connected to a second computer. According to the present invention, requests from the web browser to a server application accessible to the second computer are stored in a persistent request queue at the remote/mobile processing system. An interim response is provided to the web browser in response to the request from the client application. The stored request may be recalled to allow user modification of the stored request prior to the request being provided to the second computer for transmission to the server application.

Results of applying the Personal Software Process

Abstract: Too often, software developers follow inefficient methods and procedures. The Personal Software Process, developed by Watts Humphrey at the Software Engineering Institute, provides software engineers with a methodology for consistently and efficiently developing high quality products. The value of PSP has been shown in three case studies-three industrial software groups have used PSP and have collected data to show its effectiveness. They are: Advanced Information Services, Inc., Motorola Paging Products Group, and Union Switch and Signal Inc. Each has trained several groups of engineers and measured the results of several projects that used PSP methods. In all cases, the projects were part of the companies' normal operations and not designed for this study. The three companies offered a variety of situations useful for demonstrating the versatility of PSP. The projects at Motorola and US&S involved software maintenance and enhancement, while those at AIS involved new product development and enhancement. Among the companies, application areas included commercial data processing, internal manufacturing support, communications product support, and real time process control. Work was done in C or C++.

Self-monitoring and self-adapting operating systems

Abstract: Extensible operating systems allow applications to modify kernel behavior by providing mechanisms for application code to run in the kernel address space. Extensibility enables a system to efficiently support a broader class of applications than is currently supported. This paper discusses the key challenge in making extensible systems practical: determining which parts of the system need to be extended and how. The determination of which parts of the system need to be extended requires self-monitoring, capturing a significant quantity of data about the performance of the system. Determining how to extend the system requires self-adaptation. In this paper, we describe how an extensible operating system (VINO) can use in situ simulation to explore the efficacy of policy changes. This automatic exploration is applicable to other extensible operating systems and can make these systems self-adapting to workload demands.

Static timing analysis of embedded software

Abstract: This paper examines the problem of statically analyzing the performance of embedded software. This problem is motivated by the increasing growth of embedded systems and a lack of appropriate analysis tools.We study different performance metrics that need tobe considered in this context and examine a range oftechniques that have been proposed for analysis. Verybroadly these can be classified into path analysis andsystem utilization analysis techniques. It is observedthat these are interdependent, and thus need to beconsidered together in any analysis framework.

Towards an application framework for automated planning and scheduling

Abstract: A number of successful applications of automated planning and scheduling applications to spacecraft operations have recently been reported in the literature. However, these applications have been one-of-a-kind applications that required a substantial amount of development effort. In this paper, we describe ASPEN (Automated Planning/Scheduling Environment), a modular, reconfigurable application framework which is capable of supporting a wide variety of planning and scheduling applications. We describe the architecture of ASPEN, as well as a number of current spacecraft control/operations applications in progress.

Measuring software dependability by robustness benchmarking

Abstract: Inability to identify weaknesses or to quantify advancements in software system robustness frequently hinders the development of robust software systems. Efforts have been made to develop benchmarks of software robustness to address this problem, but they all suffer from significant shortcomings. The paper presents the various features that are desirable in a benchmark of system robustness, and evaluates some existing benchmarks according to these features. A new hierarchically structured approach to building robustness benchmarks, which overcomes many deficiencies of past efforts, is also presented. This approach has been applied to building a hierarchically structured benchmark that tests part of the Unix file and virtual memory systems. The resultant benchmark has successfully been used to identify new response class structures that were not detected in a similar situation by other less organized techniques.

Reuse of off-the-shelf components in C2-style architectures

Abstract: Reuse of large-grain software components offers the potential for significant savings in application development cost and time. Successful component reuse and substitutability depends both on qualities of the components reused as well as the software context in which the reuse is attempted. Disciplined approaches to the structure and design of software applications offers the potential of providing a hospitable setting for such reuse. We present the results of a series of exercises designed to determine how well “offthe-shelf” components could be reused in applications designed in accordance with the C2 software architectural style. The exercises involved the reuse of two user-interface constraint solvers, two graphics toolkits, a World Wide Web browser, and a persistent object manager. A subset of these components was used to construct numerous variations of a single application (thus an application family). The exercises also included construction of a simple development environment for locating and downloading a component off the Web and incorporating it into an application. The paper summarizes the style rules that facilitate reuse and presents the results from the exercises. The exercises were successful in a variety of dimensions; one conclusion is that the C2 style offers significant reuse potential to application developers. At the same time, wider trials and additional tool support are needed.1 Index Terms -software reuse, architectural styles, messagebased architectures, component-based development, graphical user interfaces (GUI).

A Hardware/software Partitioned Using A Dynamically Determined Granularity

Abstract: Computer aided hardware/software partitioning is one of the keychallenges in hardware/software co-design. While previous approacheshave used a fixed granularity, i.e. the size of the partitioningobjects was fixed, we present a partitioning approach thatdynamically determines the partitioning granularity to adapt optimizationsteps to application properties and to intermediate optimizationresults. Experiments with simulated annealing optimizationshow a faster convergence and far better adaptability to costfunction variations than in previous experiments with fixed granularity.

Modular application software for telecommunications exchanges for providing all end user services traffic handling and charging requirements of an applications type

Abstract: A software architecture for use in program controlled telecommunications switching exchanges in which application modules are employed to provide services to users of a particular communications application. Resource modules provide specific functional elements of communications services to the application modules by having access to and control over the exchange hardware. Network protocols provide communication between the application modules within the exchange and interfaces provide communications between the resource modules and between application modules and resource modules within the exchange.

Method and system for interactively developing a graphical control-flow structure and associated application software for use in a machine vision system

Abstract: A method and system are provided for interactively developing a graphical, control-flow structure and associated application software for use in a machine vision system using a computer system without the need for a user to write any code Preferably, the method and system "marry" the ActiveX control standard and the Grafcet/IEC 1131 standard The structure includes a control sequence having a plurality of steps or nodes, transitions, and links or flow lines which interconnect the nodes and transitions Hardware operating parameters are stored which correspond to possible hardware for use in the machine vision system The hardware operating parameters define a set of standard controls having properties Commands are received from the user of the computer system to select a first control program corresponding to a desired component of a user interface, desired hardware operating parameters corresponding to desired hardware and second control programs corresponding to desired machine vision algorithms Graphical representations or icons are selected which correspond to the desired second control programs and are displayed in the structure as nodes and/or inputs/outputs of the nodes The first control program is linked with the desired hardware operating parameters to the second control programs to form the application software The step of linking includes the step of setting the property of one standard control to be equal to one property of another standard control to form the application software in response to the commands without the user writing any of the application software