bluuebunny/crossref_metadata_2025 huggingface dataset:
Using Java and the socket interface in teaching client/server programming
Authors: Yang Andrew , Bachar Yael
Published: July 2004

In this poster, we present our experience developing JAVA applets and applications to create a client/server system on the world wide web, and show how the product is used in upper-division computer science classes.The set of programs consist of a client and a server. The client program in the prototype is a JAVA applet that is downloaded into the client machine and is executed in a user's web browser using the local memory, CPU and other resources. The server program in the prototype is a JAVA application that runs on a web server all the time. The client and the server programs use the socket interface [ Comer&Stevens 96] as the communication protocol, and are able to transmit data back and forth successfully over the internet. Figure 1 illustrates how the client and the server communicate over the socket interface.With the set of programs in place, students in the upper-division computer science classes, including
software engineering, databases systems, and distributed application development,
are able to build their own software for the course projects, on top of the software prototypes.Revision of a given set of JAVA programs proves to be a better approach in learning client/server programming using JAVA and sockets, compared to requiring students to create JAVA programs from the scratch.
A small contribution to editing with a syntax directed editor
Authors: Zelkowits Marvin V.
Published: July 2004

The simple design of a syntax directed editor has made them a popular research topic over the last few years; however, in practice little development time is spent in actually entering program text. Most of the effort is devoted to program maintenance. This means that the editor has to be able to handle changes easily - a task that most syntax editors handle poorly. This paper describes a syntax editor and outlines the features that make editing such programs practical. It includes a bottom up parser that is used in a variety of ways within the editor.
IDEOSY
Authors: Giacalone Alessandro , Rinard Martin C. , Doeppner Thomas W.
Published: July 2004

IDEOSY is an experiment in the use of a formal semantics as the basis for a programming system and in use of an
ideographic
language as the primary means of user-computer communication. The important characteristics of our system are that it uses an ideographic syntax, has a syntax-directed editor, supports the definition of various equivalence properties and the proofs of such equivalence, and has an interpreter. It currently runs on Apollo workstations and on VAXes running Berkeley UNIX@ using any of a variety of high-resolution color displays.

Our formalism is based on Milner's Calculus of Communicating Systems (
CCS
) [1]. We have found CCS to be a convenient formalism for describing programs and have even used it for describing the UNIX operating system [2]. Its algebraic properties are very useful for building descriptions out of components and for proving the equivalence of descriptions. Since CCS is an operational semantics, we may directly interpret descriptions written in CCS.
The Poe language-based editor project
Authors: Fischer C. N. , Johnson Gregory F. , Mauney Jon , Pal Anil , Stock Daniel L.
Published: July 2004

Editor Allan Poe (Pascal Oriented Editor) is a full-screen language-based editor (LBE) that knows the syntactic and semantic rules of Pascal. It is the first step in development of a comprehensive Pascal program development environment.

Poe's design began in 1979; version 1 is currently operational on Vax 11s under Berkeley Unix and on HP 9800-series personal workstations. Poe is written in Pascal, and is designed to be readily transportable to new machines. An editor-generating system called Poegen is operational, and much of the language-specific character of Poe is table-driven and retargetable.
Viewing a programming environment as a single tool
Authors: Delisle Norman M. , Menicosy David E. , Schwartz Mayer D.
Published: July 2004

Programming environments support the creation, modification, execution and debugging of programs. The goal of integrating a programming environment is more than simply building tools that share a common data base and provide a consistent user interface. Ideally, the programming environment appears to the programmer as a single tool; there are no firewalls separating the various functions provided by the environment. This paper describes the techniques used to integrate Magpie, an interactive programming environment for Pascal. Display windows, called browsers, provide a consistent approach for interacting with the Pascal source code or the execution state of the program. Incremental compilation allows the programmer to specify debugging actions in Pascal, eliminating the need for a separate debugging language.
ISDE
Authors: Chesi M. , Dameri E. , Franceschi M. P. , Gatti M. G. , Simonelli C.
Published: July 2004

In this paper we present ISDE, an experimental Interactive Software Development Environment. Briefly described is the design methodology for the derivation of an interactive software development environment from a set of general meta-tools and (syntactic and semantic) language definition. The internal program representation common to every environment tool is presented, along with the main features of each implemented or under development tool, emphasizing tools integration and composition capabilities.
The Darwin software-evolution environment
Authors: Minsky N. , Borgida A.
Published: July 2004

The main goal of the Darwin software development environment is to establish a rigorous authorization-based discipline which can be used to impose constraints on the structure and operations of software systems as well as on their process of development Such constraints might be desirable to serve the following needs:

• The need to provide support and enforcement for such software engineering techniques as informationhiding, data abstraction and modularization, even when these techniques are not offered by the programming language itself.

•The need to support rules which govern the real enterprise being served by the system, and which must be invariant of the evolutionary behaviou of the system.

• The need to enforce managerial policies concerning the process of system development itself.
Phoan
Authors: DeTreville John
Published: July 2004

Phoan is an experimental system for the specification and synthesis of control software over suitably restricted domains; its initial application domain is control software for distributed telephone systems. Phoan provides the developer with an example-based specification language, which it translates into an internal representation language based on rules and constraints. Phoan reasons at the representation level to ensure that the system definition is coherent and consistent with independent models of the target domain. Phoan synthesizes the final control structures and their associated protocols by transformation from the internal representation. The implementation of Phoan is currently in progress.
Preliminary experience from the dice system a distributed incremantal compiling environment
Authors: Fritzson Peter
Published: July 2004

Abstracts The DICE system Is a highly Integrated programming environment which provides programmer support in the case where the programming environment resides in a host computer and the program Is running on a target computer that Is connected to the host. Such a system configuration is also suitable for remote debugging and maintenance of production versions of programs that has been installed in a user environment.

The system contains tools such as an screen-oriented structure editor, a statement-level incremental compiler, a screen-oriented debugger and a program database. The debugger uses the same facility for pointing and display as does the editor, and it uses the incremental compiler for insertion of breakpoints and statement evaluation. Most of these tools are automatically generated from compact descriptions.

This paper describes some aspects of a prototype version of the system and gives some preliminary data on the performance. Also, strategies for implementing portable programming environments are discussed and are exemplified by the DiCE system.
Monitoring in a software development environment
Authors: Snodgrass Richard
Published: July 2004

A monitor is an important component of a software development environment. The information collected and processed by a monitor is vital for debugging and tuning programs, and is useful to compilers performing selective optimization. A relational database, extended to incorporate time, is introduced as an appropriate representation of dynamic information concerning a program's execution
. TQuel,
a language permitting high level queries about a program's behavior, is briefly described. Measurements of an initial implementation of the relational monitor show that it can efficiently support the conceptual viewpoint of a dynamic database of a program's behavior.
A programming environment for a timeshared system
Authors: Gabriel Richard P. , Frost Martin E.
Published: July 2004

In 1968 the Stanford Artificial Intelligence Laboratory began to construct a programming environment from a PDP-10, a pre-TOPS-10 DEC
1
timesharing system, and some innovative terminal hardware. By now this has developed into a programming environment for a KL-10 that integrates our editor with various other system functions, especially the Lisp subsystem. We use the term 'SAIL' to refer to the Stanford A. I. Lab KL-10 computer running the WAITS timesharing system. [Harvey 1982]

By 'programming environment' we mean the mechanisms that allow a user to type text at his program or subsystem, and which manage output text.
2
We are talking about mechanical management of the interaction between user and program, not about any intelligent mediation. A good programming environment should be flexible enough to suit individuals, yet without requiring the mechanics of interaction to be re-learned for each new program.

In this paper we describe our programming environment, what makes it unique, and why we think that it is not necessary to move to personal computers for a very usable programming environment.
Notes on the design of Euclid
Authors: Popek G. J. , Horning J. J. , Lampson B. W. , Mitchell J. G. , London R. L.
Published: July 2004

Euclid is a language for writing system programs that are to be verified. We believe that verification and reliability are closely related, because if it is hard to reason about programs using a language feature, it will be difficult to write programs that use it properly. This paper discusses a number of issues in the design of Euclid, including such topics as the scope of names, aliasing, modules, type-checking, and the confinement of machine dependencies; it gives some of the reasons for our expectation that programming in Euclid will be more reliable (and will produce more reliable programs) than programming in Pascal, on which Euclid is based.
Efficient implementation and optimization of run-time checking in PASCAL
Authors: Fischer Charles N. , LeBlanc Richard J.
Published: July 2004

Complete run-time checking of programs is an essential tool for the development of reliable software. A number of features of the programming language PASCAL (arrays, subranges, pointers, record variants (discriminated type unions), formal procedures, etc.) can require some checking at run-time as well as during compilation. The problem of efficiently implementing such checking is considered. Language modifications to simplify such checking are suggested. The possibility of optimizing such checking is discussed.
Aspects of applicative programming for file systems (Preliminary Version)
Authors: Friedman Daniel P. , Wise David S.
Published: July 2004

This paper develops the implications of recent results in semantics for applicative programming. Applying suspended evaluation (call-by-need) to the arguments of file construction functions results in an implicit synchronization of computation and output. The programmer need not participate in the determination of the pace and the extent of the evaluation of his program. Problems concerning multiple input and multiple output files are considered: typical behavior is illustrated with an example of a rudimentary text editor written applicatively. As shown in the trace of this program, the driver of the program is the sequential output device(s). Implications of applicative languages for I/O bound operating systems are briefly considered.
Some extensions to algebraic specifications
Authors: Guttag Jhon V. , Horowitz Ellis , Musser David R.
Published: July 2004

Algebraic specifications of abstract data types are beginning to gain wide currency. In this paper we discuss an extension to this specification technique which allows the specification of procedures which alter their parameters, and various ways of handling the specification of error conditions.
Software reliability
Authors: Melliar-Smith P. M. , Randell B.
Published: July 2004

The paper discusses the basic concepts underlying the issue of software reliability, and argues that programmed exception handling is inappropriate for dealing with suspected software errors. Instead it is shown, using an example program, how exception handling can be combined with the recovery block structure. The result is to improve the effectiveness with which problems due to anticipated faulty input data, hardware components, etc., are dealt with, while continuing to provide means for recovering from unanticipated faults, including ones due to residual software design errors.
Exception handling in PL/I
Authors: MacLaren M. Donald
Published: July 2004

The PL/I language's facilities for handling exceptional conditions are analyzed. The description is based on the new PL/I standard. Special attention is given to fine points which are not well known. The analysis is generally critical. It emphasizes problems in regards to implementation and structured programming. A few suggestions for future language design are offered.
Early experience with Mesa
Authors: Geschke Charles M. , Morris James H. , Satterthwaite Edwin H.
Published: July 2004

The experiences of Mesa's first users—primarily its implementers—are discussed, and some implications for Mesa and similar programming languages are suggested. The specific topics addressed are:

module structure and its use in defining abstractions,

data-structuring facilities in Mesa,

equivalence algorithm for types and type coercions,

benefits of the type system and why it is breached occasionally,

difficulty of making the treatment of variant records safe.
Abstraction and verification in Alphard
Authors: Shaw Mary , Wulf Wm A. , London Ralph L.
Published: July 2004

The Alphard
form
provides the programmer with a great deal of control over the implementation of abstract data types. In this paper we extend the abstraction techniques from simple data representation and function definition to the
iteration statement
, the most important point of interaction between data and the control structure of the language itself. We introduce a means of specializing Alphard's loops to operate on abstract entities without explicit dependence on the representation of those entities. We develop specification and verification techniques that allow the properties of the
generators
for such iterations to be expressed in the form of proof rules. We obtain results for common special cases of these loops that are essentially identical to the corresponding constructs in other languages. We also provide a means of showing that a generator will terminate.
An interactive demonstration system for implementations of abstract data types
Authors: Hitz Martin
Published: July 2004

A dialogue-oriented tutorial system to visualize various kinds of implementations of abstract data types (ADTs) like
LIST, STACK, QUEUE
, or
SET
is presented.The system runs on a PRIME 750 mini-computer and supports an advanced course on data structures and algorithms by graphically showing the way the ADT's primitive operations (like
MakeNull, Insert, Delete
etc.) can be realized by Pascal-procedures using different basic data types. The user walks through the Pascal-code when accessing the data structure. Help-screens explain the basic concepts of the algorithms under investigation.This paper describes the capabilities of the system and shows an example of its usage.
Software reuse myths
Authors: Tracz Will
Published: July 2004

Reusing software is a simple, straightforward concept that has appealed to programmers since the first stored-program computer was created. Unfortunately, software reuse has not evolved beyond its most primitive forms of subroutine libraries and brute force program modification. This paper analyzes nine commonly believed software reuse myths. These myths reveal certain technical, organizational, and psychological software engineering research issues and trends.
Integrated projection illustrating
Authors: Smestad Tore , Andersen Kristian
Published: July 2004

This paper suggests "Integrated Projection Illustrating" as a concept to be used in connection with visual descriptions of some complexity. It is meant both as an explanatory framework for what has been done so far, and as a guiding tool for making more efficient and complete "packages" of visual information in general and of diagraming in software engineering in particular. Known principles and pieces of techniques are put together to make up a unified basis.
An extended systems modeling language (ESML)
Authors: Bruyn William , Jense Randall , Keskar Dinesh , Ward Paul
Published: July 2004

ESML
(Extended Systems Modeling Language) is a new system modeling language based on the Ward-Mellor and Boeing structured methods techniques, both of which have proposed certain extensions of the DeMarco data flow diagram notation to capture control and timing information. The combined notation has a broad range of mechanisms for describing both combinatorial and sequential control logic.
The small computer assisted lecturing system
Authors: Piotrowski Jerzy A.
Published: July 2004

Intensive courses are conducted by an instructor who is often supported by one or more assistants. However, for certain density of assignments, the work in such teams is difficult to organize and control. Then, the computer-assistant becomes indispensable. A teaching method is presented which offers many individual small and medium size assignments from 3--4 different subjects taught by a single instructor during a semester. An average number of 55 documents is processed and 150 grading decisions taken per day, without any help of a human assistant. The teaching concept is a traditional one and based on the assumption that scholars already have prepared courseware for many subjects. Also specific methods and tricks are worked out and well-tested. The system is attractive for staff members because it assures not only better teaching standards, but also leaves them more time for research. Finally, it is worthwhile to mention that powerful software systems are offered to support administrative functions of the university, but the needs of an individual instructor remain somehow forgotten.The system is implemented on IBM PC and requires a mini-system like VAX-780 only to print or display forms for students.
Computer science homework and grading practices: an alternative to the popular model
Authors: Sanders Sidney L.
Published: July 2004

The approach to homework used in elementary school and high school is also popular in college computer courses, particularly those involving programming. Regardless of its popularity, there are compelling reasons to eschew this approach at the college level. This paper outlines the major problems inherent in the high school approach, and proposes an alternative. The proposed model provides opportunities for learning and maturation, while preventing further erosion of the meaning of an academic grade.
Teaching computer networks as a writing intensive course
Authors: Quirk James R. F.
Published: July 2004

A senior level course in Computer Networks was included in Radford University's Writing-Intensive Course program. This implied that writing was used in every facet of the course by the students and by the instructor. The volume and the diversity of the writing significantly enhanced the educational experience from both points of view. Some beneficial effects and some detrimental ones on the amount of subject matter covered were experienced. The fundamental nature of the course, however, was not altered, and the net effects of the writing are seen as very beneficial.
A microprogramming project for a course in computer systems
Authors: Harris J. Archer
Published: July 2004

This paper describes a microprogramming project in a course in Computer Systems and Architecture. The project requires the students to write a machine language emulator on a simple microarchitecture. The limited scope of the machine language and the simplicity of the microarchitecture reduce the project to a manageable size. A simulator implements the microarchitecture, producing tracing output which allows students to follow the flow of their microprograms. The project and the simulator have proved to be a useful tools in teaching the concepts of emulation and microcoding.
Systems analysis and design: an orphan course about to find a home
Authors: Poole Bernard John
Published: July 2004

A course in Systems Analysis and Design (SA&D) as a component of the curriculum in Computer Science (CS) has not traditionally been given high priority at the undergraduate level. As a result students have been poorly prepared for the reality of a working world where large software projects frequently founder, and sometimes fail, for lack of project management and experience. There is a need for "real" software project experience within the framework of a college curriculum. This is not an unrealistic expectation, even though it presents a particularly demanding pedagogical challenge. The solution may be in a marriage between SA&D and Software Engineering (SE). At the University of Pittsburgh at Johnstown we are introducing such a component this coming academic year (87--88). We hope that this will go some way toward giving our students a taste for the inherent complexity of large software systems. We also present a recent experience with "real" project development from which we have gained insights for future course design.
Deadlock detection in distribution object systems
Authors: Kaveh Nima , Emmerich Wolfgang
Published: July 2004

The behaviour of a distributed system is largely determined by the use of synchronization primitives and threading policies of the underlying middleware. The inherent parallel nature of distributed systems may cause liveness problems, such as deadlocks and livelocks. An increasing number of distributed systems is built using object middleware. We exploit the fact that modern object middleware offers only a few built-in synchronization and threading primitives by suggesting UML stereotypes to represent each of these primitives in distributed object design. We define the semantics of the stereotypes using a process algebra. We use that semantics to translate UML diagrams into behaviourally equivalent process algebra representations and can then use model checking techniques to find potential deadlocks. The paper also shows how the model checking results can be related back to the original UML diagrams.
Increasing client-side confidence in remote component implementations
Authors: Jagannathan Ramesh , Sivilotti Paolo A.G.
Published: July 2004

When a client makes use of a remote component, it does not have direct access to the remote component's implementation or state information. By observing the component's interactions with its environment, however, the client can determine whether the component's behavior conforms to its promised specification. We present a distributedinfrastructure with which a client can make these observations and thereby increase its confidence in the correctness of the remote component. This infrastructure supports temporal specifications of distributed components with autonomous threads of control. It also supports multiple levels of confidence, with commensurate performance costs. As a proof-of-concept for this design, we have implemented a prototype in Java for distributed systems built using CORBA.
A micromodularity mechanism
Authors: Jackson Daniel , Shlyakhter Ilya , Sridharan Manu
Published: July 2004

A simple mechanism for structuring specifications is described. By modelling structures as atoms, it remains entirely first-order and thus amenable to automatic analysis. And by interpreting fields of structures as relations, it allows the same relational operators used in the formula language to be used for dereferencing. An extension feature allows structures to be developed incrementally, but requires no textual inclusion nor any notion of subtyping. The paper demonstrates the flexibility of the mechanism by application in a variety of common idioms.
Detecting implied scenarios in message sequence chart specifications
Authors: Uchitel Sebastian , Kramer Jeff , Magee Jeff
Published: July 2004

Scenario-based specifications such as Message Sequence Charts (MSCs) are becoming increasingly popular as part of a requirements specification. Scenario describe how system components, the environment and users work concurrently and interact in order to provide system level functionality. Each scenario is a partial story which, when combined with other scenarios, should conform to provide a complete system description. However, although it is possible to build a set of components such that each component behaves in accordance with the set of scenarios, their composition may not provide the required system behaviour. Implied scenarios may appear as a result of unexpected component interaction. In this paper, we present an algorithm that builds a labelled transition system (LTS) behaviour model that describes the closest possible implementation for a specification based on basic and high-level MSCs. We also present a technique for detecting and providing feedback on the existence of implied scenarios. We have integrated these procedures into the Labelled Transition System Analyser (LTSA), which allows for model checking and animation of the behaviour model.
A formal approach to the assessment and improvement of terminological models used in information systems engineering
Authors: Wendorff Peter
Published: July 2004

In the design and implementation of any information system identifiers are used to designate concepts. Typical examples are names of classes, variables, modules, database fields, etc. A terminological model is a set of identifiers together with a set of abstractions and a set of links between identifiers and abstractions. Naturally, terminological models embody important knowledge of a system, and therefore they play an important role during the development of information systems. In this paper we propose a metamodel for terminological models that is based on category theory as conceptual and notational framework.
Using aspectC to improve the modularity of path-specific customization in operating system code
Authors: Coady Yvonne , Kiczales Gregor , Feeley Mike , Smolyn Greg
Published: July 2004

Layered architecture in operating system code is often compromised by execution path-specific customizations such as prefetching, page replacement and scheduling strategies. Path-specific customizations are difficult to modularize in a layered architecture because they involve dynamic context passing and layer violations. Effectively they are vertically integrated slices through the layers. An initial experiment using an aspect-oriented programming language to refactor prefetching in the FreeBSD operating system kernal shows significant benefits, including easy (un)pluggability of prefetching modes, independent development of prefetching modes, and overall improved comprehensibility.
A notation for problematic architecture interactions
Authors: Davis L. , Gamble R. , Payton J. , Jónsdóttir G. , Underwood D.
Published: July 2004

The progression of component-based software engineering (CBSE) is essential to the rapid, cost-effective development of complex software systems. Given the choice of well-tested components, CBSE affords reusability and increases reliability. However, applications developed according to this practice can often suffer from difficult maintenance and control, problems that stem from improper or inadequate integrate solutions. Avoiding such unfortunate results requires knowledge of what causes the interoperability problems in the first place. The time for this assessment is during application design. In this paper, we define
problematic architecture interactions
using a simple notation with extendable properties. Furthermore, we delineate a multi-phase process for pre-integration analysis that relies on this notation. Through this effort, potential problematic architecture interactions can be illuminated and used to form the initial requirements of an integration architecture.
Automatic abstraction for model checking software systems with interrelated numeric constraints
Authors: Choi Yunja , Rayadurgam Sanjai , Heimdahl Mats P.E.
Published: July 2004

Model checking techniques have not been effective in important classes of software systems characterized by large (or infinite) input domains with interrelated linear and non-linear constraints over the input variables. Various model abstraction techniques have been proposed to address this problem. In this paper, we wish to propose
domain abstraction
based on data equivalence and trajectory reduction as an alternative and complement to other abstraction techniques. Our technique applies the abstraction to the input domain (environment) instead of the model and is applicable to
constraint-free
and deterministic
constrained
data transition system. Our technique is automatable with some minor restrictions.
An algebraic approach to file synchronization
Authors: Ramsey Norman , Csirmaz El″od
Published: July 2004

A
file synchronizer
restores consistency after multiple replicas of a filesystem have been changed independently. We present an algebra for reasoning about operations on filesystems and show that it is sound and complete with respect to a simple model. The algebra enables us to specify a file-synchronization algorithm that can be combined with several different conflict-resolution policies. By contrast, previous work builds the conflict-resolution policy into the specification, or worse, does not specify the synchronizer's behavior precisely. We classify synchronizers by asking whether conflicts can be resolved at a single disconnected replica and whether all replicas are identical after synchronization. We also discuss timestamps and argue that there is no good way to propagate timestamps when there is severe clock skew between replicas.
A methodology for specifying and analyzing consistency of object-oriented behavioral models
Authors: Engels Gregor , Küster Jochem M. , Heckel Reiko , Groenewegen Luuk
Published: July 2004

Object-oriented modeling favors the modeling of object behavior from different viewpoints and the successive refinement of behavioral models in the development process. This gives rise to consistency problems of behavioral models. The absence of a formal semantics for UML models and the numerous possibilities of employing behavioral models within the development process lead to the rise of a number of different consistency notions. In this paper, we discuss the issue of consistency of behavioral models in the UML and present a general methodology how consistency problems can be dealt with. According to the methodology, those aspects of the models relevant to the consistency are mapped to a semantic domain in which precise consistency tests can be formulated. The choice of the semantic domain and the definition of consistency conditions can be used to construct different consistency notions. We show the applicability of our methodology by giving an example of a concrete consistency problem of concurrent object-oriented models.
Engineering component-based net-centric systems for embedded applications
Authors: Jahnke Jens H.
Published: July 2004

The omnipresence of the Internet and the World Wide Web (Web) via phone lines, cable-TV, power lines, and wireless RF devices has created an inexpensive media for telemonitoring and remotely controlling distributed electronic appliances. The great variety of potential benefits of aggregating and connecting embedded systems over the Internet is matched by the currently unsolved problem of how to design, test, maintain, and evolve such heterogeneous, collaborative systems. Recently, component-oriented software development has shown great potential for cutting production costs and improving the maintainability of systems. We discuss component-oriented engineering of embedded control software in the light of emerging requirements of distributed, net-centric systems. Our approach is baed on applying the graphical specification language SDL for composing complex networks of embedded software components. From the SDL specification, we generate internet-aware connector components to local embedded controller networks. The described research is carried out in a collaborative effort between industry and academia.
Analysis of the constraint solver in UNA based test data generation
Authors: Edvardsson Jon , Kamkar Mariam
Published: July 2004

In a series of articles Gupta et al. develop a framework for automatic test data generation for computer programs. In general, their approach consists of a branch predicate collector, which derives a system of linear inequalities representing the branch predicates for a given path in the program. This system is solved using a solving technique of theirs called the Unified Numerical Approach (UNA) [5, 7]. In this paper we show that in contrast to traditional optimization methods the UNA is not bounded by the size of the solved system. Instead it depends on how input is composed. That is, even for very simple systems consisting of one variable we can easily get more than a thousand iterations. We will also give a formal proof that UNA does not always find a mixed integer solution when there is one. Finally, we suggest using some traditional optimization method instead, like the simplex method in combination with branch-and-bound and/or a cutting-plane algorithm as a constraint solver.
Coverage criteria for GUI testing
Authors: Memon Atif M. , Soffa Mary Lou , Pollack Martha E.
Published: July 2004

A widespread recognition of the usefulness of graphical user interfaces (GUIs) has established their importance as critical components of today's software. GUIs have characteristics different from traditional software, and conventional testing techniques do not directly apply to GUIs. This paper's focus is on coverage critieria for GUIs, important rules that provide an objective measure of test quality. We present new coverage criteria to help determine whether a GUI has been adequately tested. These coverage criteria use events and event sequences to specify a measure of test adequacy. Since the total number of permutations of event sequences in any non-trivial GUI is extremely large, the GUI's hierarchical structure is exploited to identify the important event sequences to be tested. A GUI is decomposed into
GUI components
, each of which is used as a basic unit of testing. A representation of a GUI component, called an
event-flow graph
, identifies the interaction of events within a component and
intra-component criteria
are used to evaluate the adequacy of tests on these events. The hierarchical relationship among components is represented by an
integration tree
, and
inter-component coverage criteria
are used to evaluate the adequacy of test sequences that cross components. Algorithms are given to construct event-flow graphs and an integration tree for a given GUI, and to evaluate the coverage of a given test suite with respect to the new coverage criteria. A case study illustrates the usefulness of the coverage report to guide further testing and an important correlation between event-based coverage of a GUI and statement coverage of its software's underlying code.
An empirical study on the utility of formal routines to transfer knowledge and experience
Authors: Conradi Reidar , Dybå Tore
Published: July 2004

Most quality and software process improvement frameworks emphasize written (i.e. formal) documentation to convey recommended work practices. However, there is considerable skepticism among developers to learn from and adhere to prescribed process models. The latter are often perceived as overly "structured" or implying too much "control". Further, what is relevant knowledge has often been decided by "others"---often the quality manager. The study was carried out in the context of a national software process improvement program in Norway for small- and medium-sized companies to assess the attitude to formalized knowledge and experience sources. The results show that developers are rather skeptical at using written routines, while quality and technical managers are taking this for granted. This is an explosive combination. The conclusion is that formal routines must be supplemented by collaborative, social processes to promote effective dissemination and organizational learning. Trying to force a (well-intended) quality system down the developers' throats is both futile and demoralizing. The wider implications for quality and improvement work is that we must strike a balance between the "disciplined" or "rational" and the "creative" way of working.
Component revision identification based on IDL/ADL component specification
Authors: Brada Přemysl
Published: July 2004

Although software components have become one of the mainstream technologies, they still lack a supportive versioning scheme. This paper describes a system for revision identification of released components with well defined semantics. It is based on the analysis of changes in the component IDL or ADL specification structured into a hierarchy of traits and categories of declarations.
8th European workshop on software process technology
Authors: Ambriola Vincenzo , Greenwood R. Mark
Published: July 2004

In this paper we report on the 8th European Workshop on Software Process Technology held in Witten (Germany) in June 2001. We also report on the outcome of a working session about the future directions of research in software process technology that will be addressed in the next workshop of this series.
Software architecture in a changing world
Authors: Nord Robert L. , Paulish Daniel J. , Schwanke Robert W. , Soni Dilip
Published: July 2004

It is now generally accepted that separating software architecture into multiple views can help in reducing complexity and in making sound decisions about design trade-offs. Our four views are based on current practice; they are loosely coupled, and address different engineering concerns [1]. This tutorial will teach you how global analysis can improve your design, and how to use UML to describe these views. You will learn: (1) the purpose of having separate software architecture views, (2) the differnce between using UML for software architecture and the use of UML for designing OO implementations, (3) how to apply global analysis to analyze factors that influence the architecture and to develop strategies that guide the design, (4) the importance of designing for anticipated change to produce more maintainable architectures, and (5) how to incorporate software architecture design in your software process. This tutorial is aimed at experienced softwre engineers, architects, and technical managers. It is assumed that participants know the basic UML diagrams. Experience in developing models and software design is helpful.
Component technologies
Authors: Emmerich Wolfgang , Kaveh Nima
Published: July 2004

This one-day tutorial is aimed at software engineering practitioners and researchers, who are familiar with object-oriented analysis, design and programming and want to obtain an overview of the technologies that are enabling component-based development. We introduce the idea of component-based development by defining the concept and providing its economic rationale. We describe how object-oriented programming evolved into local component models, such as Java Beans and distributed object technologies, such as the Common Object Request Broker Architecture (CORBA), Java Remote Method Invocation (RMI) and the Component Object Model (COM). We then address how these technologies matured into distributed component models, in particular Enterprise Java Beans (EJB) and the CORBA Component Model (CCM). We give an assessment of the maturity of each of these technologies and sketch how they are used to build distributed architectures.
Engineering of Web services with XML and XSL
Authors: Kirda Engin
Published: July 2004

The important role of Web services in businesses and organizations is undisputed today. The construction and management of large Web services is still a challenge. The life cycle of a Web service includes the analysis, design, implementation and maintenance stages and Web service engineering covers all phases of Web service life cycle. The majority of Web tools developed so far only address the implementation phase and lack support for the other stages. Furthermore, emerging requirements such as the support for mobile devices have introduced new challenges and problems developers have to deal with. The World Wide Web Consortium's eXtensible Markup Language (XML) and the eXtensible Stylesheet Language (XSL) are standards defined in the interest of multi-purpose publishing and content reuse and are increasingly being deployed in the construction of Web services. This tutotial shows how to design, implement, and manage adaptable XML/XSL-based Web services. It discusses and presents our experiences in maintaining and building the Vienna International Festival Web service. It gives a brief overview of popular Web engineering technologies and some tools we have developed. The tutorial also examines the common difficulties, non-difficulties, and solutions of Web service engineering and presents work being done in the area.
From use cases to code---rigorous software development with UML
Authors: Zündorf Albert
Published: July 2004

The Rational Unified Process lacks technical guidance for the development of object-oriented applications. This tutorial fills this gap. We first use UML scenario diagrams to analyze use-cases. Next, we show a method to analyze scenarios and to derive UML class diagrams and UML behavior modeling for active classes and methods. We show how to choose and embed design patterns in a design and how to employ different architectural styles. From such a precise design, smart CASE tools generate fully functional implementations. We explain state-of-the-art code generation concepts for UML and assess current CASE tools for their code generation capabilities and for their support through all software development phases more generally.
Peer-to-peer information systems
Authors: Aberer Karl , Hauswirth Manfred
Published: July 2004

The limitations of client/server systems become evident in an Internet-scale distributed environment. P2P systems offer an alternative to traditional client/server systems: Every node acts both as a client and a server and "pays" its participation by providing access to its computing resources. Systems such as Napster and Gnutella have proven their practical applicability. In this tutorial we position the P2P paradigm in the design space of distributed information systems, present underlying models and concepts, and show the structure, protocols, and algorithms of current systems. Then we elaborate on the novel requirements for P2P algorithms (resource discovery, complexity, and scalability) and present future research areas.
Formal foundations of software evolution
Authors: Mens Tom , Wermelinger Michel
Published: July 2004

The workshop on
Formal Foundations of Software Evolution
was co-located with the
5th European Conference on Software Maintenance and Reengineering
(CSMR 2001), which took place at the Centro de Congressos do Instituto Superior Tcnico in Lisbon, Portugal, March 14 to 16, 2001. The workshop was organised in the context of the
Scientific Research Network on Foundations of Software Evolution.
This is a research consortium coordinated by the Programming Technology Lab of the Vrije Universiteit Brussel (Belgium), and it involves 9 research institutes from universities in 5 different European countries (Belgium, Germany, Austria, Switzerland, and Portugal). The consortium is financed by the Fund for Scientific Research - Flanders (Belgium).One full day was allocated for the workshop (March 13, 2001). There were 14 participants, that all contributed with a position paper which was reviewed and revised before the workshop. Next to the submissions of the research consortium partners, there were also participants from research institutes in Spain, United Kingdom, Finland, and Japan. In preparation to the workshop, participants were requested to read all other submissions, and asked to prepare a clear position statement and questions that were likely to stimulate discussion.The goal of the workshop was to get more insight into how formal techniques can alleviate software evolution problems, and how they can lead to tools for the evolution of large and complex software systems that are more robust and more widely applicable without sacrificing efficiency. Preferably, the evolution-support tools should not be restricted to a particular phase of software evolution [BR00], but should be generally applicable throughout the entire application lifetime. The tools should also provide support for different aspects of software engineering, such as forward engineering, reverse engineering, re-engineering, and team engineering.In order to stimulate discussions, three general important questions were posed to the participants at the beginning of the workshop:

Which aspects of software evolution need to be automated by tools?

Where and how can formalisms help us to achieve tool support?

How can we build formally-founded tools that are as general and flexible as possible? Note that the generality and flexibility of a tool involves many different aspects:

     --- independence of the programming language for which support should be provided;

     --- customisability by the user of the tool;--- applicability in or across different stages of software evolution;

     --- interoperability with other tools;

     --- scalability to large and complex software systems with multiple developers;

     --- usable for static (design-time) as well as dynamic (runtime) evolution;

     --- applicable to forward, reverse, and re-engineering;

     --- usable before, during, and after evolution;

     --- usable for facilitating, supporting, as well as analysing evolution;

     --- to deal with the
what and why
as well as the
how
of software evolution
4th ICSE workshop on "Software Engineering over the Internet"
Authors: Maurer Frank , Zannier Carmen
Published: July 2004

The 4th ICSE workshop on "Software Engineering over the Internet" brought together researchers and practitioners that are trying to use Internet technologies to overcome problems in distributed software development. The goal of the workshop was to exchange ideas how distributed projects can utilize the Internet to overcome communication, collaboration, and coordination problems. We summarize the presented papers of the workshop