bluuebunny/crossref_metadata_2025 huggingface dataset:
Creating reference architectures
Authors: Batory Don , Coglianese Lou , Goodwin Mark , Shafer Steve
Published: July 2004

ADAGE is a project to define and build a domain-specific software architecture (DSSA) environment for assisting the development of avionics software. A central concept of DSSA is the use of software system generators to implement component-based models of software synthesis in the target domain [SEI90].

In this paper, we present the ADAGE component-based model (or reference architecture) for avionics software synthesis. We explain the modeling procedures used, review our initial goals, show how component reuse is achieved, and examine what we were (and were not) able to accomplish. The contributions of our paper are the avionics reference architecture and the lessons that we learned; both may be beneficial to others in future modeling efforts.
A logical framework for software proof reuse
Authors: Caplan Joshua E. , Harandi Mehdi T.
Published: July 2004

We describe a logical framework PR for verification of reusable software components. Within our system, developers can employ the advantages traditionally associated with software reuse to reduce the cost of software verification by reusing abstract proofs and specifications. One can construct an algorithm with parameters, a specification with parameters, and a proof that the algorithm satisfies the specification provided the parameters satisfy certain conditions. Proofs in
PR
will themselves contain parameters for subproofs concerning those conditions. In this framework, typing, type checking, and proof checking are decidable.
Principles for writing reusable libraries
Authors: Fowler Glenn S. , Korn David G. , Vo Kiem-Phong
Published: July 2004

Over the past 10 years, the Software Engineering Research Department in AT&T has been engaging in a research program to build a collection of highly portable advanced software tools known as Ast, Advanced Software Technology. A recent monograph, “Practical Reusable UNIX Software” (John Wiley & Sons, Inc., 1995), summarizes the philosophy and components of this research program. A major component of this program is a collection of portable, and reusable libraries servicing a wide range of functions, from a porting base to all known UNIX platforms, to efficient buffered I/O, memory allocation, data compression, and expression evaluation. The libraries currently stand at about 150,000 non-commented lines of C code. They are developed and maintained independently by different researchers. Yet they work together seamlessly—largely because of a collection of library design principles and conventions developed to help maintaining interface consistency and reducing needless or overlapped work.
Organization domain modeling (ODM)
Authors: Simos Mark A.
Published: July 2004

Researchers and practitioners are looking for systematic ways of comparing domain analysis (DA) methods. Comparisons have often focused on linkage between DA methods and related technologies such as systems modeling. Less attention has been paid to comparing DA methods in terms of certian core methodological issues, including problems of scoping, contextualizing, descriptive vs. prescriptive modeling, and formalized models of variability. This paper presents key aspects of Organization Domain Modeling (ODM), a systematic domain analysis method structured in terms of a core domain modeling life cycle directly addressing these methodological concerns.
Development of reusable expert system components
Authors: Dai W.
Published: July 2004

This paper addresses the metrics of expert system reusability through practical experience obtained in developing and using a previously implemented system called INDEX. It presents a principled approach in defining expert system component granularity, transparency, and a specification methodology in identifying and building reusable expert system skeletons and components to allow them to be used in most conventional software environments. The adoption of such an approach has led to the production of reusable expert system components for different expert system development projects. The preliminary experience in reusing INDEX facilities has been presented. Two applications are chosen to show the effectiveness of such an approach.
Reuse of requirements and specifications
Authors: Paredes Carlos , Fiadeiro José Luiz
Published: July 2004

It is claimed that requirements engineering, as a problem of formalization and agreement, can benefit from raising the level of reusability up to functional requirements elicitation and specification levels. At these levels, it is important to support incomplete information in a declarative, reusable and refineable form. For that purpose, a model is proposed which is based on temporal theories, in the logical sense, together with a set of incremental specification techniques formalized through categorial constructions on theories.
Systematic software reuse (panel)
Authors: Griss Martin , Jacobson Ivar , Jette Chris , Kessler Bob , Lea Doug
Published: July 2004

Ensuring that object technology will achieve its promise of significant software reuse requires that special attention be paid to a combination of people, process and technology issues. Reuse will not happen automatically. The panelists will describe their experience with OO reuse and their views on the issues.
PATHOS—a paradigmatic approach to high-level object-oriented software development
Authors: Agarwal Rakesh , Lago Patricia
Published: July 2004

The growing complexity of information systems and the ensuring problems of their development, maintenance and management have highlighted the inadequacy of formal and informal methods for constructing such systems. These problems manifest themselves in the computer systems which are often unmanageable, unreliable, inflexible and hence difficult to maintain. Users have often demanded for reliable computer systems because they realize that most failures are due to poor specification, and design. This has resulted in the emergence of a number of information systems methodologies together with associated computerized development environments in which the Object-Oriented (OO) approach is one of the most recent.OO is often used for promoting software development and its reuse. Languages like Smalltalk reduce not only development time but also the cost of maintenance, simplifying the creation of new systems and the reuse of old ones. Nevertheless OO is not a panacea i.e. efforts are to put in for its proper use. Thus we consider OO as a paradigm which provides a new image, a new way of conceptualizing the development life cycle. By the help of paradigms, software developers and users are supported in apprehending the development life cycle and means to organize the aspects of the life cycle into a comprehensive method.PATHOS (A Paradigmatic Approach To High-level Object-Oriented Software development) aims to demonstrate an approach to information system development that will lead not only to good information system creation, but also to explicitly represent the maintenance of the business knowledge so as to allow for its more effective and active exploitation at run time.
The correctly analyzed system which behaves incorrectly
Authors: Ryant Ivan
Published: July 2004

Many systems analysts believe that strictly following a methodology prevents them from producing incorrect system specification. In fact, banking systems, telephone exchanges and other information and control systems may fail in any moment because of hidden errors. This article explains that the most widespread methodologies nowadays aid rising of dangerous synchronization errors in the specification. What's the matter? The methodologies isolate interacting concurrent processes one from other. In order to analyze concurrent behavior, we need to consider interactions as a whole. We must not split interactions into separate processes.Systems analysis aims to specify information systems. There are several approaches to the systems analysis. The two main streams today are structured and object oriented analysis. Unfortunately, both of them hide the danger of incorrect synchronization without giving the analyst any chance to control it. Perhaps, the most delusive case of incorrect synchronization are time - dependent errors. Concurrent system is the system of concurrent (sequential) processes that may interact (communicate or synchronize each other).
A framework for understanding the integration of design methodologies
Authors: Song Xiping
Published: July 2004

Software researchers and practitioners have studied and used a number of approaches to integrating major design paradigms in order to improve Software Design Methodologies (SDMs). Software tool developers have developed tools to aid the integration and customization of existing SDM support tools. However, a framework for understanding and guiding various integration and customization processes is still lacking. Because of this users, even with tool support, often fail to systematically integrate SDMs and SDM support tools.In this paper, we define a framework that can be used to understand various SDM integrations and customizations. Through this definition, we describe what kinds of integrations are useful, what difficulties are to be met, and how the integrity of the SDMs can be maintained.
Creating formal specifications from requirements documents
Authors: Amoroso Edward G.
Published: July 2004

An approach is introduced for creating a model-based formal specification from an informal requirements document. The approach employs a structured categorization and evolutionary refinement of informal requirements to functional requirements, goals, implementation demands, theorems, and axioms stated with respect to a formal specification. The evolutionary refinement terminates when the specification and axioms can be expressed using constructs in a target specification language. Guidance is provided for integrating requirements changes, existing automated support, and informal design activities into the refinement. The approach is demonstrated using informal requirements for an RS-232 repeater device.
Toward better software automation
Authors: Jazaa Adid
Published: July 2004

This paper discusses the concept and advantages of automating software activities. It also addresses software production costs and the problems associated with software development. A logic-based framework for managing the complexity of software projects is proposed. The main investigations and suggestions are summarised.
The path-wise approach to data flow testing with pointer variables
Authors: Marx Delia I. S. , Frankl Phyllis G.
Published: July 2004

This paper describes a new approach to performing data flow testing on programs that use pointer variables and a tool based on this approach. Our technique is based on the observation that, under certain reasonable assumptions, we can determine which dereferenced pointers are aliased whenever control reaches a given program point
via a particular path.
Furthermore, we can group together paths which behave similarly and represent them by regular expressions. The resulting test requirements demand that the test data execute representatives of particular sets of paths between variable definitions and uses.
Automated test data generation for programs with procedures
Authors: Korel Bogdan
Published: July 2004

Test data generation in program testing is the process of identifying a set of test data that satisfies a selected testing criterion, such as, statement coverage or branch coverage. The existing methods of test data generation are limited to unit testing and may not efficiently generate test data for programs with procedures. In this paper we present an approach for automated test data generation for programs with procedures. This approach builds on the current theory of execution-oriented test data generation. In this approach, test data are derived based on the actual execution of the program under test. For many programs, the execution of the selected statement may require prior execution of some other statements that may be part of some procedures. The existing methods use only control flow information of a program during the search process and may not efficiently generate test data for these types of programs because they are not able to identify statements that affect execution of the selected statement. Our approach uses data dependence analysis to guide the process of test data generation. Data dependence analysis automatically identifies statements (or procedures) that affect the execution of the selected statement and this information is used to guide the search process. The initial experiments have shown that this approach may improve the chances of finding test data.
Elements of style
Authors: Jackson Daniel , Damon Craig A.
Published: July 2004

We illustrate the application of Nitpick, a specification checker, to the design of a style mechanism for a word processor. The design is cast, along with some expected properties, in a subset of Z. Nitpick checks a property by enumerating all possible cases within some finite bounds, displaying as a counterexample the first case for which the property fails to hold. Unlike animation or execution tools, Nitpick does not require state transitions to be expressed constructively, and unlike theorem provers, operates completely automatically without user intervention. Using a variety of reduction mechanisms, it can cover an enormous number of cases in a reasonable time, so that subtle flaws can be rapidly detected.
Constructing abstract models of concurrent real-time software
Authors: Corbett James C.
Published: July 2004

Concurrent real-time software is used in many safety-critical applications. Assuring the quality of such software requires the use of formal methods. Before a program can be analyzed formally, however, we must construct a mathematical model that captures the aspects of the program we want to verify. In this paper, we show how to construct mathematical models of concurrent real-time software that are suitable for analyzing the program's timing properties. Our approach differs from schedulability analysis in that we do not assume that the software has a highly restricted structure (e.g., a set of periodic tasks). Also, unlike most more abstract models of real-time systems, we account for essential properties of real implementations, such as resource constraints and run-time overhead.
Formal specification and verification of the kernel functional unit of the OSI session layer protocol and service using CCS
Authors: Barjaktarovic Milica , Chin Shiu-Kai , Jabbour Kamal
Published: July 2004

This paper describes an application of formal methods to protocol specification, validation and verification. Formal methods can be incorporated in protocol design and testing so that time and resources are saved on implementation, testing, and documentation. In this paper we show how formal methods can be used to write the control sequence, i.e. pseudo code, which can be formally tested using automated support. The formal specification serves as a blueprint for a correct implementation with desired properties.As a formal method we chose a process algebra called "plain" Calculus of Communicating Systems (CCS). Our specific objectives were to: 1) build a CCS model of the Kernel Functional Unit of OSI session layer service: 2) obtain a session protocol specification through stepwise refinement of the service specification; and 3) verify that the protocol specification satisfies the service specification. We achieved all of our objectives. Verification and validation were accomplished by using the CCS's model checker, the Edinburgh Concurrency Workbench (CWB). We chose plain CCS because of itssuccinct, abstract, and modular specifications, strong mathematical foundation which allows for formal reasoning and proofs, and existence of the automated support tool which supports temporal logic. The motivation for this work is: 1) testing the limits of CCS's succinct notation; 2) combining CCS and temporal logic; and 3) using a model-checker on a real-life example.
Working results on software re-engineering
Authors: Leite Julio Cesar Sampaio do Prado
Published: July 2004

We view software re-engineering as a new approach to software maintenance. Instead of performing maintenance at the source code of systems, we work on high level abstractions. From these abstractions we proceed in a forward manner reusing the available implementations, when it is the case. As such, we view re-engineering as centered on design recovery. We have been working on methods for re-engineering and applying them to real cases. Our studies are centered on the idea of using JSD [Jackson 83] as a way of casting the recovered design. We worked with two small systems and a complex one. Our objective here is to highlight our approach, report on what has been done and point out what was learned.
Educating software executives
Authors: Shoemaker Dan , Jovanovic Vladan
Published: July 2004

This presents a model that integrates "best theory and practice" into a doctoral program focused on the development of leaders for the software industry. The advantage of a study centered on improvement of the software process should be intuitively obvious. This provides an overview, a model, and a course array.
Productive maintainability
Authors: Barranco García Manuel J. , Granja Alvarez Juan Carlos
Published: July 2004

It is obvious the existence of a powerful connection between quality and productivity in the software projects. Normally, an increase of quality bring to a greater productivity. Maintainability is a very important factor of quality, considering the enormous consumption of resources that is carried out during the maintenance stage. We comment in this article the relation between maintainability and productivity, and when the maintainability result productive and when not.
Internet connection for Web access
Authors: Blum Howard
Published: July 2004

This paper describes a simplified model of a bottleneck in user access to the World-Wide Web. It has been used to illustrate performance modeling, queueing analysis and simulation in courses on simulation and computer networking.
A new emphasis & pedagogy for a CS1 course
Authors: Evans M. D.
Published: July 2004

A CS1 course introduces students to fundamental aspects of computing science. Invariably, these aspects are ones of content (subject matter). There is an alternative, and arguably more beneficial, role for a CS1 course - it could introduce the fundamental
processes
and
concepts
which pervade
all
computing science content domains, and which have but different instantiations in the different domains. This article considers the identification of these aspects, and suggests a pedagogy suitable for their emphasis. This pedagogy is applied to a traditional CS1 programming-content domain, resulting in a proposal for a new CS1 curriculum.
Conference on computer-aided software engineering summary report
Authors: Tatsuta Tanehiro
Published: July 2004

The fifth Conference on Computer-Aided Software Engineering was held July 10-12, 1996 in Tokyo in conjunction with CASE Japan'96. The general chair, Yoshihiro Matsumoto (University of OSAKA Institute of Technology), organized the program, along with the vice-chair, Hiroshi Mukaiyama (Japan Information Processing Developing Center), Ichiro Moriyama (Reed Exhibitions Japan), and the 17 members of the program Screening Committee. Reed Exhibitions Japan sponsored the Conference and all the related events as well.The program consisted of the Keynote Address and 20 sessions. I have selected several features out of the program and have submitted here as a Summary Report on behalf of all the members of the Committee so as to attempt to capture the essence of the Conference.
On the scalability problem in COTS-based programming environments
Authors: Favaro John
Published: July 2004

This article reports on a software design experience in which the concept of scalability is applied to the architecture of a software development environment based upon Commercial-Off-The-Shelf (COTS) tools. The experience has raised many issues, which are summarized here together with attempts to analyse their origins and indicate solutions. We believe that problems with the introduction of scalability will be encountered by any project attempting the integration of heterogeneous COTS products.
NDHORM
Authors: Zhang Jiazhong , Wang Zhijian
Published: July 2004

In this paper, we propose an OO approach to requirement modeling, which includes a hierarchical object-oriented requirements model NDHORM and its requirements modeling procedure. The NDHORM model concentrates on capturing and simulating dynamic interaction relationships between problem objects in a real world, as well as the stepwise refinement of interacting objects during the modeling process. A behavior-directed method and its uniform notations for identifying objects, attributes, services, relationships, etc. are also provided.
Parallel and distributed algorithms: laboratory assignments in Joyce/Linda
Authors: Elenborgen Bruce S.
Published: July 2004

A NSF ILI grant funded development of parallel and distributed laboratories for an undergraduate course in parallel algorithms. The laboratory assignments explored various parallel and distributed architectures, and paradigms. These assignments were implemented using the Joyce/Linda[McDonald92] language. The Joyce/Linda software was also utilized to develop parallel and distributed laboratory assignments for courses in data structures, operating systems and computer networks. The parallel and distributed algorithms course examined both theoretical and practical areas of study.
Teaching inheritance versus inclusion to first year computer science students
Authors: Reek Kenneth A.
Published: July 2004

This paper describes two laboratory experiments used at the Rochester Institute of Technology to teach first year CS students the difference between inheritance and inclusion (aggregation, composition).
A supplementary package for distance education students studying introductory programming
Authors: McGill Tanya , Hobbs Valerie
Published: July 2004

Teaching introductory programming can be a challenging task. Students can become too concerned with learning syntax at the expense of more general conceptual understanding. Distance education students in particular often have problems as the difficulty of the course content is compounded by the problems of isolation from other students and their tutor. Although instructional strategies for emphasising conceptual knowledge are well known for face-to-face instruction, there has been little attempt to apply them to the external situation. This paper describes a supplementary package for external students designed to address some of these problems. The package has been used for two semesters and feedback from students indicates that they find it a valuable resource.
The INGRES Tutorial as a tool in teaching database theory (or, I can't believe it's not training)
Authors: Goelman Don
Published: July 2004

The course in database principles is an example of a course in the computer science curriculum in which a balance is sought between theory and applications. With some exceptions, most computer science majors at the author's university prefer material which is oriented towards what they view as practical applications. At best, they tolerate the theoretical component of their courses. In particular, many who enroll in the database course hope to acquire expertise in particular software. One of the course projects has managed to finesse this prejudice by hiding some theoretical ideas in the benign cloak of an application.
Inspections of formal specifications
Authors: Hilburn Thomas B.
Published: July 2004

This paper describes a student peer review process that has been incorporated within an introductory course in formal methods. As a course project, a team of students develops a formal specification of the requirements for a software system. The final part of the project involves the inspection of the specification by another team of student reviewers. The paper presents a rationale for including inspections as part of a formal methods course. It provides a detailed description of the inspection process and reports on the application of the process to a specific class project. Finally, the paper assesses the results of the use of such a paradigm and discusses how to improve it.
A simple student environment for lightweight process concurrent programming under SunOs
Authors: Berk Toby S.
Published: July 2004

This paper describes a simplified student environment for lightweight processes (threads) under SunOs or compatible systems. The environment is built on top of the SunOs lwp package. A range of concurrency facilities are provided including critical sections, events and signals, and monitors. A hidden scheduler enhances the effects of the nondeterminacy, even for small student programs. A sample assignment is shown using the package.
CALOS
Authors: Goldberg Murray W.
Published: July 2004

This paper describes CALOS, our application of computer-aided learning to a third-year Computer Science course in Operating Systems. The delivery tool we choose is the World Wide Web. The course material consists of interactive exercises, interactive simulations and demonstrations, on-line notes, student - instructor communication mechanisms, student - student communication mechanisms, progress tracking, navigational aids, student evaluations, a glossary and a bibliography. We make use of text, images, animations and voice. We plan to offer the course experimentally in several modes in order to determine the best use of the hypermedia presentation.
Blue—a language for teaching object-oriented programming
Authors: Kölling Michael , Rosenberg John
Published: July 2004

Teaching object-oriented programming has clearly become an important part of computer science education. We agree with many others that the best place to teach it is in the CS1 introductory course. Many problems with this have been reported in the literature. These mainly result from inadequate languages and environments. Blue is a new language and integrated programming environment, currently under development explicitly for object-oriented teaching. We expect clear advantages from the use of Blue for first year teaching compared to using other available languages. This paper describes the design principles on which the language was based and the most important aspects of the language itself.
Writing across the computer science curriculum
Authors: Fell Harriet J. , Proulx Viera K. , Casey John
Published: July 2004

At our university, as at many others across the country, there is a movement to integrate the common core subjects with the disciplinary studies. While in the past writing has been a domain of English departments, the new trend is 'writing across curriculum'. It is clear that effective written and oral communication skills are critical for the successful computer professional.We present suggestions for writing assignments that complement the main themes of computer courses from introductory to advanced levels. While some of these have appeared in the literature, others are new. We report on our experience with these assignments and reflect on how they enhance the computer science curriculum.
The EOS laboratory environment for a course in operating systems
Authors: Erickson Carl
Published: July 2004

This paper describes a laboratory environment for teaching operating systems. The EOS (Exploratory Operating Systems) lab was developed with a National Science Foundation ILI grant to be used in conjunction with a traditional operating systems (OS) course. The main goal of the EOS project was to improve the teaching of operating system principles without the necessity of a special purpose laboratory and the addition to the curriculum of a second course in OS. The EOS labs are summarized and a CPU scheduling lab is described in some detail. A standardized testing instrument was used to compare class performance before and after adding the lab to the OS course. Preliminary results show an improvement attributable to the EOS laboratory. The author's experience in building a workstation laboratory from an externally funded grant is described.
An electronic class photo album
Authors: Reek Margaret M. , Reek Kenneth A.
Published: July 2004

This paper describes our experience developing and using an electronic class photo album for our introductory CS courses at Rochester Institute of Technology. Each course's album is arranged by lab and lecture sections, and includes a picture of each student and a short personal biography. Mosaic or Netscape are used to access and display the album.
Easing into C++
Authors: Lemone Karen A. , Ching Walter
Published: July 2004

RoBOTL is an on-going language experiment that attempts to blend Karel the Robot, as developed by Richard E. Pattis, [Pattis, 1982] with the object-oriented paradigm and the C/C++ language syntax. We developed it to ease the introduction of C++ as a first programming language. Its initial debut in the summer
Frontiers in Science
program at WPI was more successful than we anticipated with the weaker students all learning to program, and the stronger students showing interest in learning the object-oriented paradigm inherent in the language. All the students were able to make the transition to C++.
Teaching software engineering through real-life projects to bridge school and industry
Authors: Song Ki-Sang
Published: July 2004

To educate graduates to succeed in industries which demand high quality software engineers is not easy due to rapidly changing organization styles and working environments. The major limitation of university education may be the lack of opportunity to expose students to real field problems. In this article, we present our experience of exposing graduate students to a real-time plant monitoring and control software development project and show how the software engineering process has been customized to educate them and satisfy the user requirements at the same time.
A presentation and comparison of four information system development methodologies
Authors: Mannino P
Published: July 2004

The objective of this paper is to provide a comparison of the following four information processing system development methodologies: The Box Structure Methodology, Application Prototyping, JSD and SASD. Each approach provides a unique and different set of activities that can be followed, with emphasis on different aspects of the life cycle. For this reason, no one methodology is superior in all areas and aspects of the development life cycle. However, each one is superior in its own sense, depending on the type of system being developed. The Box Structure Methodology provides a rigorous coverage of the analysis and design phases in the development life cycle, with the use of design graphics, and a design graphics language. JSD and SASD also use graphical structures as well. However, SASD relies heavily on dataflow diagrams in the analysis and design phases, where as JSD incorporates functions, time requirements, actions, and data into its diagrams in the analysis phase, and then applies them in the implementation phase, without ever going through a design step. Finally, the Application Prototyping development methodology offers an approach that centers around the development of a prototype, which is heavily dependent upon user interaction with the user in the feasibility and analysis phases, but does not offer any design, implementation, or maintenance techniques. A methodology is only approiate for a developer, once he/she has considered these fact, and determined the system's target environment.
Design by objectives
Authors: Gilb T
Published: July 2004

We have developed a set of co-operative methods and languages for describing a software engineering problem, its solutions and its intermediary products. The main characteristic of the method, known as Design by Objectives (DBO), is its ability to deal with all system attributes quantitatively. The DBO method is based on specification and design languages which are written, unambiguous, structured, integrated with each other flexible in when and where to apply them, capable of being scaled up or down to suit project viewpoint and scale of project, and capable of being applied to all aspects of system design, including all possible components of a software system. Since 1979 we have built a series of experimental personal computer automated support systems based on the DBO languages, in an attempt to see how they might be constructed and what value they might give the user. In addition many elements of the DBO languages have been put to extensive industrial use by the authors, their clients and by other users of the methods, including several computer manufacturers.
Softool uses' group meets
Authors: Galbraith J
Published: July 2004

The fifth semiannual international meeting of the Softool Users' Group was held in Parsippany, N.J., Sept. 22 and 23. Over 70 users, Softool representatives, and guests attended the two-day event, which was hosted by the U.S. Army ARDEC. The major highlight of this meeting was the presentation of case studies describing the methodologies used to automate change and configuration management in different specific environments through the use of Softool's Change and Configuration Control (CCC™).
On constructing Karnaugh maps
Authors: Thompson Don
Published: July 2004

Karnaugh [5] created a technique for finding the minimal sum of products form of a boolean function, a technique which is commonly included in the now popular Discrete Mathematics textbooks. Karnaugh maps are introduced in these texts as a topological bridge between boolean algebra and combinational networks, affording a technique for reducing the number of logic gates required to represent a boolean function. This paper will discuss a new, simple method for constructing Karnaugh maps recursively.
A crisis in computer science education at liberal arts colleges
Authors: Scrugg Greg W
Published: July 2004

A crisis now pervades computer science education at small liberal arts colleges: too many programs are not able to boot strap their programs into existence at a level where they can sustain themselves. The costs, not necessarily in dollars, have far exceeded the original expectations of the colleges, resulting in inappropriate environments, inadequate educational goals, broken faculty careers and unrealistic research expectations, and ultimately failure of the programs as bonafide computer science. In what follows, I take as a given that computer science is not only an appropriate, but a central and important discipline for liberal arts colleges. This has been argued elsewhere and will not be addressed here, as my primary concern is with the institutions which have (at least officially) accepted this premise.I will first attempt to describe the major symptoms and then the causes of some of the problems encountered by many small liberal arts colleges. Finally, I will offer a preliminary set of suggestions for possible solution.
An exemplary approach to the education of rule-based languages
Authors: Schikuta Erich
Published: July 2004

In this paper an exemplary approach to the education of rule-oriented languages will be presented and a method will be proposed to organize lectures on rule-oriented languages.The author of this paper developed the SIEGER-System, which serves as an assistance for such lectures. It is the implementation of a practical rule-based system using PROLOG, a rule-based language.The system is excellently suitable to show the analogy of the metalingual rule-system description and the formal PROLOG definition, and the equality of the natural way of the system usage and the automatic PROLOG-backtracking algorithm.For this reason the above mentioned exemplary approach in connection with this system is outstandingly appropriate for the education of computer science students.
Using object-oriented typing to support architectural design in the C2 style
Authors: Medvidovic Nenad , Oreizy Peyman , Robbins Jason E. , Taylor Richard N.
Published: July 2004

Software architectures enable large-scale software development. Component reuse and substitutability, two key aspects of large-scale development, must be planned for during software design. Object-oriented (OO) type theory supports reuse by structuring inter-component relationships and verifying those relationships through type checking in an architecture definition language (ADL). In this paper, we identify the issues and discuss the ramifications of applying OO type theory to the C2 architectural style. This work stems from a series of experiments that were conducted to investigate component reuse and substitutability in C2. We also discuss the limits of applicability of OO typing to C2 and how we addressed them in the C2 ADL.
Report on the fifth European workshop on software process technology
Authors: Montangero Carlo
Published: July 2004

This is a short resume of the actual proceedings of the fifth European Workshop on Software Process Technology, held in Nancy, 9-11 October 1996. It is a post-hoc integration of the report that is included in the proceedings of the fourth International Conference on the Software Process, held in Brighton, UK, 3-5 December 1996, and published by IEEE Press. It is based on the presentations of the session rapporteurs, whom I gratefully acknowledge, together with E. Ellmer, who took minutes of the last wrap-up session. The papers that triggered the discussions are available by Springer Verlag, as volume 1149 of the Lecture Notes in Computer Science.
Report from the NSF workshop on workflow and process automation in information systems
Authors: Sheth Amit , Georgakopoulos Dimitrios , Joosten Stef M. M. , Rusinkiewicz Marek , Scacchi Walt , Wileden Jack , Wolf Alexander L.
Published: July 2004

An interdisciplinary research community needs to address challenging issues raised by applying workflow management technology in information systems. This conclusion results from the NSF workshop on Workflow and Process Automation in Information Systems which was held at the State Botanical Garden of Georgia during May 8-10, 1996. The workshop brought together active researchers and practitioners from several communities, with significant representation from database and distributed systems, software process and software engineering, and computer supported cooperative work. The presentations given at the workshop are available in the form of an electronic proceedings of this workshop at http://lsdis.cs.uga.edu/activities/). This report is the joint work of selected representatives from the workshop and it documents the results of significant group discussions and exchange of ideas.
Integrating information requirements along processes
Authors: Francalanci C. , Fuggetta A.
Published: July 2004

Information requirements have traditionally been collected separately for different business functions and then integrated into an overall specification. The recent orientation to a process perspective in managing business activities has emphasized early integration, by concurrently analyzing business processes and information requirements. Accordingly, information requirements analysis methodologies should take into account these new integration needs. In the paper, we discuss these new integration needs. Traditional methods for requirements integration from database design are analyzed and unfulfilled integration needs are highlighted. Then, other research fields are surveyed that dealt with problems similar to integration and offer interesting results: Recent developments in database design, software engineering and requirements reuse. Finally, we compare the different contributions and indicate open research directions.
A behaviorally-based methodology for modeling system specifications
Authors: Mathalone Sigal
Published: July 2004

The Behaviorally-Based Methodology (BBM), a methodology for modeling behaviorally-complex system requirements specifications, is introduced in this paper. The BBM provides guidelines for a Behaviorally-Based decomposition beginning at the first stage of system development, while placing the emphasis on system behavior and providing notations to represent this behavior. In Behaviorally-Based system modeling, all active services and system behavior at each instant are presented in one place (the relevant system state). Hence, problem domain information is more easily carried through the analysis phase allowing for a clear separation between system analysis and system design. In addition, inconsistencies in describing system behavior can be avoided more easily; where such problems occur they are detected and resolved with greater facility.The BBM is compared to more functional approaches, such as Hatley and Pirbhai's approach [1], highlighting the BBM's advantages. An experiment conducted in a graduate software engineering class is described. The experiment has shown that system modeling performance was significantly improved, in both accuracy and speed, when following the BBM. These design benefits of the BBM are then discussed and illustrated.
An object-based model for
p
prototyping user interfaces of cooperative systems
Authors: Bing Mao , Li Xie
Published: July 2004

This paper presents an object-based model to support the construction of user interfaces of CSCW systems. The model divides a cooperative system into layers and each layer is formed by component objects. A principal focus of the model is the provision of an object linking mechanism which links the relevant objects in the same interactive layers of multiple users to realize multi-level collaboration which is independent of the application. In addition, multi-level collaboration obtains fine-grained collaboration of the cooperative system and improves its collaboration efficiency. The object-based method used in this paper ensures a structured collaboration, realizes a simple collaboration management, and facilitates cooperative system development.
Lessons learned with ACME an environment integration experiment
Authors: Gintell John W. , Memmi Gérard
Published: July 2004

ACME is an integration experiment with Marvel (a process centered environment) and ConversationBuilder (a CSCW system). Scrutiny, a collaborative software inspection system built with ConversationBuilder, is the subject application that operates in the integrated environment. The integration methodologies used by ACME are control integration, data integration, and tool integration. This paper describes the components and conceptual design of ACME and the effect that ACME has on the operation of Scrutiny. It also describes the lessons learned during this project. These lessons are categorized into those concerned with concept validation, integration issues, system design issues, software agent integration, and implementation and testing issues.
Hypertext implications for CASE environments
Authors: Drori Offer
Published: July 2004

The article discusses hypertext and its use in the development of CASE based information systems. Information systems development is a lengthy process, comprising various phases dealing with different development processes --- from systems analysis, to system characterization and design, and culminating in the setting up of the system and assimilation by users. This is called the information system life cycle. The technology which deals with computerization of the various phases of information systems development is called CASE, or Computer-Aided Software Engineering. The work of the planner and programmer is frequently conducted in different work environments according to the phases of the system life cycle. To date, no computerized interface exists between the various environments, so that, in effect, management of the development phases is partially manual.The aim of this article is to show that a hypertext approach can be used to deal with the current difficulties in CASE-based information systems development. The basic premise of this article is that the CASE system should be viewed as a database, over which an appropriate dynamic hypertext model can then be defined. This approach differs from all other CASE approaches, which view CASE solely as a tool or working environment.Hypertext was developed in recent years to cope with the growing need for computer-aided management of large databases (particularly text-based ones). Hypertext enables the building of a large database and creation of information nodes with links between them, which make it possible to manage and control the many elements dispersed through numerous environments. This article sets out to show that it is possible to harness hypertext to manage many CASE-based work environments, thereby creating a computerized tool which draws together different work environments and enables management and control of its various elements.
Creating reusable architectures
Authors: Lam W.
Published: July 2004

Achieving systematic reuse of software designs requires the creation of a reusable software architecture. This paper describes initial experience of creating reusable architectures in the avionics domain. A case-study is presented which illustrates the RACE (Reusable Architecture Creation and Employment) process. In RACE, a variability analysis is used to identify possible variations in a family of systems, which then guides the creation of a generic architecture and a set of architectural "plug-ins." The paper concludes with a set of RACE guidelines which summarises our initial experience.
A reuse triplet for systematic software reuse
Authors: Mugisa Ezra K.
Published: July 2004

We present the view that for systematic software reuse (SSR) to happen we need a reuse software architecture (RSA) as the invariant base and a collection of reuse software components (RSCs) as the pluggable variant part of a family of architecturally similar software systems. We shall identify a reuse situation with a RSA, RSCs and a plugging operator. SSR is then presented as a case of plugging a collection of RSCs into the appropriate RSA. We apply this view of reuse to a number of reuse cases and find evidence that for reuse to be successful we need simple, clear and easily pluggable RSAs and RSCs.
System calls and interrupt vectors in an operating systems course
Authors: Holliday Mark A.
Published: July 2004

The introductory operating systems course has a tendency to appear to the student as a disparate collection of topics such as synchronization primitives, process scheduling algorithms, and page replacement policies. We describe a sequence of material to cover early in the operating systems course that prevents this tendency by clarifying the goal of the course and by providing a framework for understanding how the later course material is used in kernel design. The material centers around two concepts. First is the importance of the abstraction provided by the system call interface, that the kernel is the implementation of that interface, and the analogy with the instruction set interface the student has already encountered. Second is how the interrupt vector mechanism in a broad sense is central to how the kernel functions and underpins the actual implementation of many of the other topics in the course. Illustration through code from a real operating system kernel is a key feature of how this sequence makes clear the workings of an operating system.
Assessing computer usage patterns in a software development course
Authors: Parrish Allen , Cordes David , Lester Cynthia , Moore Deanne
Published: July 2004

This paper reports the results of an exploratory study that measures computer usage patterns in a second-year, programming-intensive computer science course. In the study, we augmented the compilation process to unobtrusively mail a copy of the compiler listing to a central location. We then analyzed these data relative to the number of compiles and their time distribution in order to characterize computer usage patterns among the students. Our results show little correlation between any particular usage pattern and the quality of the final product.