bluuebunny/crossref_metadata_2025 huggingface dataset:
The web of system properties
Authors: Whitworth Brian
Published: July 2004

This paper considers why informed computer predictions are so often wrong. A limited perspective seems to be a factor. It is proposed that a general understanding of the nature of systems is necessary to predict and create the future of information systems. Based on a general definition, a set of system properties is proposed which can be applied equally to human-created and natural systems, i.e. to hardware and software as well as organisms and societies. Assigning values to each property allows a system "web" to be drawn representing its overall performance. The model predicts that Windows will displace DOS, but that electronic mail will not displace paper communication. It is suggested that a balanced view of system properties will not only allow better prediction of future information systems trends, but allow design of information systems which avoid the "revenge" effects common with new technologies.
Systems for multi-level teaching materials
Authors: Sajaniemi Jorma , Kuittinen Marja
Published: July 2004

Lecturers need three kinds of supporting materials: lecture notes given to learners, presentation material to be shown in the lectures, and lecturer's own guidance material to direct her during the lecture. Hardly any of the current presentation systems supports easy preparation and maintenance of these three interwoven material sources. In this paper, we describe two systems that can be used for authoring and presentation of multiple-level teaching materials.
Developing a digital library of computer science teaching resources
Authors: Copperman Elana , Dann Wanda , Goldweber Michael , Hartman Janet , Kuittinen Marja , Mutchler David , Parlante Nick , Grissom Scott , Knox Deborah
Published: July 2004

We describe recommendations for how to plan and develop a web-based digital library to support computer science education, i.e., the online Computer Science Teaching Center (CSTC) . This report details three facets: the identification of appropriate resources for inclusion in the CSTC, the review process for submissions, and the development and promotion of CSTC. A taxonomy of teaching resources is provided, and includes informal feedback from ITiCSE '98 conference participants enumerating desirable materials. Categories recommended for inclusion are: Labware / Courseware, Presentation / Exposition, On-line Course, Small Assignment, and Large Assignment. A formal review process is defined and detailed in order to insure that high quality materials are contained in the CSTC. A core set of reviewer guidelines is presented, suitable for the resources identified. Finally, recommendations for the marketing and the mechanics of the site are presented. The CSTC initially will support materials of visualizations, laboratory projects, and NSF CISE Education Innovation projects. Strong association with professional organizations, such as ACM and IEEE, is recommended. The working group unanimously recommends that access to CSTC resources should remain free of charge, to serve the widest possible audience.
Java resources for computer science instruction
Authors: Bland Constance G. , Hartley Stephen J. , Holliday Mark A. , Lawhead Pamela B. , Lewis John , McNally Myles F. , Nevison Christopher H. , Ng Cheng , Pothering George J. , Teräsvirta Tommi , Bergin Joseph , Naps Thomas L.
Published: July 2004

The goal of this working group was to collect, evaluate, and foster the development of resources to serve as components of both new and revised traditional courses that emphasize object-oriented software development using Java. These courses could, for example, integrate Internet-based distributed programming, concurrency, database programming, graphics and visualization, human interface design and object-oriented development. They could therefore also be suitable as capstone courses in computer science. The focus of the working group was on tools and techniques, including demonstrations, projects, syllabi, and pedagogical patterns. The working group members are coordinating the development of a Web site (sol.pace.edu/iticse98) devoted to sharing such tools and techniques among educators.
Ethical issues related to Internet development and research
Authors: Anderson G. Ernest , Roth R. Waldo , Varden Stuart A. , Medley M. Dee , Rutherfoord Rebecca H.
Published: July 2004

This paper discusses ethical issues concerning Internet development, presentation and research. A brief overview of the major ethical issues related to computing is followed by a discussion of ethical issues specific to the use of the Internet. We will look at the implications of these issues for particular population groups such as children, women, disabled persons, and the low socio-economic class. Finally, we offer suggestions for how these issues can be brought into the computer or information science classroom in a way that stimulates critical thinking skills.
A domain specific software architecture style for CSCD system
Authors: Li Baojian , Zeng Guangzhou , Lin Zongkai
Published: July 2004

This paper proposes a domain-specific software architecture style. In the architecture style we define three software component types: procedure components, object components and agent components. We design a software bus or connector called Tribus to facilitate interactions among these components and specify one way quotation relations between different component types and two-way quotation relations between components of the same type. We also give an application example of the software architecture style in the domain of Computer Supported Collaborative Design (CSCD).
Integration of text retrieval technology into formatted (conventional) information systems
Authors: Drori Offer
Published: July 2004

Conventional information systems are characterized by data management, which is formatted according to the characterization, prepared by a systems analyst, in conjunction with the user of the new system. The operating principles of these systems enable efficient data management and the resolution of a broad range of problems. At times, systems of this nature do not meet the complex needs of an organization, such as the management of data that is difficult to characterize precisely, or the management of occasional activities that do not justify a separate system, etc.Text retrieval technology provides management of "open" data, as well as a wide range of other data management forms. This paper presents the advantages of integrating text retrieval technology into formatted information systems in order to solve the above problems.
Measuring formal specification with α-metric
Authors: Kokol Peter
Published: July 2004

This paper explains the use of α - metrics in analysing and comparison of various formal specification languages.
Issues in calibrating effort estimation models
Authors: Vesterinen Petri
Published: July 2004

This paper discusses some important issues when calibrating, or developing effort estimation models for software projects. The author has developed and calibrated several effort estimation models within Nokia Corporation. The paper takes use of the experience gained in those situations.
A construction approach for software agents using components
Authors: Hong Liu , Zongkai Lin , Guangzhou Zeng
Published: July 2004

This paper presents a construction approach for software agents. A software agent is regarded as a main frame plus some components, and it is constructed by selecting suitable main frame and software components, assembling and running through the control mechanism on the main frame. The multi-agent system is organised on the Client/Server model. The developed system based on this method profits from software reuse in the distributed environment.
A formula for the re-inspection decision
Authors: Adams Tom
Published: July 2004

Various recommendations concerning the re-inspection decision can be found in the literature. Some are based on general assumptions or estimates concerning the downstream cost of defects and the proportion of defects that get past the inspection "filter". None of these recommendations allow you to work with your own data or assumptions concerning specific types of documents. This article provides a way to make the re-inspection decision using your own data.
Software engineering
Authors: Holmes Neville
Published: July 2004

This note reviews aspects of professionalism as related to computers, questions the structuring of responsibilities in software development, and commends subsuming overspecialized branches of engineering, such as Computer Systems Engineering and Software Engineering, within a more general discipline of Data Engineering.
Query generation in an instructional database management system
Authors: Czejdo Bogdan , Rusinkiewicz Marek
Published: July 2004

The objectives and the general structure of a database management system designed for instructional use are described in this paper. Two high level interfaces which can be used to assist a student in query formulation are discussed. First of these interfaces is graphical and uses Macintosh microcomputer as a user's workstation. The other interface guides a student through the process of query formulation using a menu-driven approach. Preliminary experiences with these interfaces have shown that they can facilitate teaching of query formulation and help students to understand better the syntax and semantics of non-procedural query languages.
Teaching personal computer Cobol with Watcom Cobol
Authors: Trigg Joseph W. Jr.
Published: July 2004

The teaching transition from a mainframe language to a subset of the same language for personal computer use could be an unpleasant experience without adequate preparation. This paper is intended to be of benefit for the teachers of COBOL who are contemplating a change from mainframe COBOL to the WATCOM COBOL interpreter.
A comparison of concurrent languages: a class project
Authors: Dobbs Verlynda
Published: July 2004

This paper describes a class project for a graduate level course in systems programming which emphasizes concurrency issues.
Mathematics support for computing degrees: a small college perspective
Authors: Sigman Scott
Published: July 2004

This paper describes a study of the required mathematical support for the computing program at Southwest Baptist University. A list of requisite mathematical concepts identified in four core courses is presented. Additionally, the results of a survey of required mathematics support courses for eighty-four small colleges and universities offering computing programs are presented and contrasted with the concepts identified by the study. The results highlight the need for a freshmen level discrete mathematics course.
Issuing each undergraduate student a personal computer: living with it for three years
Authors: Mein Bill
Published: July 2004

Clarkson University was the first university to issue incoming freshmen a desktop computer system. The program has been in place for three years; now all incoming undergraduates receive a desktop system. Last year, the university did a study to determine its computing needs for the next five years. Students were surveyed for their remarks regarding the computing facilities — including the desktop program. This paper notes some of those findings as well as some comments made by the faculty who were surveyed.
Leadership style vs. success in student chief programmer teams
Authors: Tenny Ted
Published: July 2004

The style of leadership on chief programmer teams was inferred from student peer evaluations, using a sample of 87 teams over a seven-year period. The strongest correlations with team success resulted from diligent attention (or lack thereof) to the duties of the Chief Programmer, Backup, and Librarian, rather than from leadership personality factors.
A pragmatic approach to systems analysis and design
Authors: Fritz Jane M.
Published: July 2004

The University of New Brunswick offers a wide selection of upper year Computer Science electives. Systems analysis and design, consisting of the study and use of the system life cycle for developing business information systems together with associated techniques and issues, has been offered for about 14 years. Considered to be a “soft” subject in a sea of hard-core technical courses, for many years this course was elected by a manageable maximum of 15-25 students per year. In recent years, particularly due to reinforcement by an active group of employers in our expanding co-op program, the value of such a course has been more widely recognized by our students. This paper examines methods used to handle substantial enrollment increases (40-60 students) in a subject which is especially sensitive to class size. Efforts made to improve the effectiveness of teaching this non-technical but vital material to technically oriented students are discussed. As well, the differences between software engineering and systems analysis and design are outlined. A case is made for a change in the ACM Curriculum '78 Software Design course CS14 to relect the very important role of the analysis phase in software development.
Dealing with disparate audiences in computer science courses using a project group within a traditional class
Authors: Roth R. Waldo , White Arthur
Published: July 2004

A frequent problem in advanced computer science courses is having students enrolled in a single class whose backgrounds range from upper division students with significant work experience to sophomores who have completed only a few computer science courses. This paper proposes a solution to this problem by combining a research project for those advanced students within a traditional course for the remaining enrollees. Although the specific course dealt with in this instance is data communications, it is believed that the model proposed is transportable to other advanced courses in computer science which have students with varied backgrounds.
Teaching technical reviews in a one-semester software engineering course
Authors: Collofello James S.
Published: July 2004

Software technical reviews are essential to the development and maintenance of high quality software. These review processes are complex group activities for which there exist an abundance of basic concepts evolved over years of practical experience. In a typical one-semester software engineering course very little of this information is adequately conveyed to students. Texts supporting this course are also very weak in this area. This paper provides a practical approach for teaching about software technical reviews in a one-semester software engineering course. The contents for two to three lectures on this topic are described as well as suggested exercises and an approach for integrating technical reviews with the usual team project. An extensive annotated bibliography is also provided to assist instructors and students.
Realistic student projects
Authors: Joel William J.
Published: July 2004

When a student performs a project, under the supervision of a faculty member, it is important that the student feel that the project is of merit and reflects both the student's capabilities as well as the student's interests. All too often the project is fine unto itself but has no connection to the student's other studies or background except that the project falls in the same major field.

Therefore it is important to create a project, in cooperation with a student, that is not only challenging in itself but also relies heavily upon the student's previous coursework. It should mimic project work as performed outside the academic sphere in that it yields a useable result.

Through the use of techniques such as a contract for project grade, outlining attainable goals agreed upon by both the student and the instructor, the student gains an understanding of the project in relation to the student's entire course of studies, as well as future endeavors.
What academic impact are high school computing courses having on the entry-level college computer science curriculum?
Authors: Franklin Roger E.
Published: July 2004

It appears that the computer revolution is irreversible and almost every Americians' life will be affected by the use of its technology. More and more jobs will require computer literacy and skills, and as a result more courses will be offered by secondary schools to prepare their students. As this area of computer technology expands, the job market will require individuals that have been trained with various amounts of knowledge and skill. Many states are requiring a certain degree of computer literacy for high school graduation. These requirements are resulting in the development of secondary curriculum guides at the state and national levels.
A case study of programming with abstract data types in a data structures course
Authors: Brown Walter E.
Published: July 2004

We describe a programming problem (and its solution) successfully used several times in a data structures course to teach an approach to the use of abstraction and abstract data types in programming by stepwise refinement.
Teaching programming algorithms aided by computer graphics
Authors: Maxim Bruce R. , Elenbogen Bruce S.
Published: July 2004

Effects of operations on abstract data objects are often difficult for students to comprehend. Visual models can be helpful to students, when the connections among the data object models, virtual machine representations of data objects, and algorithms operating on the data objects are made clear to the students.

This paper discusses the design criteria used to develop a series of Pascal programs, implemented on widely used microcomputers, which make use of graphics to illustrate the effects of programming algorithms on common data structures. These programs were designed to be used in classroom demonstrations and by individual students working in the computing laboratory.
1

A non-machine specific design of an algorithm teacher is proposed. It is a programmed environment to help students in a beginning computer science course learn problem solving skills. This paper provides an overview of the problem, a motivation and justification, followed by a brief description of what the program should provide the student.
Providing activities for students to apply data structures concepts
Authors: Hartman Janet , Chrisman Carol
Published: July 2004

This paper will describe possible types of activities that can be used in a data structures course to give students experience applying the concepts being taught. It is suggested that problems be presented within a real context and in situations where there is more than one reasonable solution. Having students develop possible data structure solutions for a problem, determine appropriate criteria for comparison of the solutions, evaluate the solutions, and select a solution for a particular problem will provide them with valuable experience. In order to successfully do this, students need to have some experience using their analysis and synthesis skills to solve problems involving data structures. Many real life problems require not just one data structure but a combination of several data structures. Students will benefit from designing data structures for both simple and complex problems. They will not only have learned what each data structure is and how to manipulate it, but also when to use each particular data structure.
Conversion of a PDP-11/40 assembler and simulator from mainframe Pascal to Ada on IBM PC microcomputers
Authors: Gayer Richard , Beise Catherine M. , Owen G. Scott
Published: July 2004

The assembly language course at Georgia State University is taught using a PDP-11/40 Assembler and Simulator, written in Pascal, running on a Sperry UNIVAC mainframe. In the past two years most of the computer science program has been switched to IBM PC compatible microcomputers. This, coupled with the fact that the UNIVAC system is about to be retired, motivated us to translate the PDP-11/40 system to the microcomputers. The translation is from the mainframe Pascal version to Ada for the PC's. The use of the assembler and simulator, the rationale for the use of Ada, and the problems encountered in the translation are all discussed.
The control of a toy robot ARM: a real time programming experience
Authors: Figueroa Mario A.
Published: July 2004

The problem of controlling a non-intelligent toy robot arm at the device level renders itself as a perfect candidate for real-time programming applications because it involves the coordination of a set of concurrent activities which have to satisfy strict timing and space constraints. The problem can be tackled in a non-structured fashion by using ad-hoc programming techniques or in a more structured fashion which reveals the true nature of the problem and solves it in a general way extensible to similar problems. It is our belief that since the problem involves the coordination of concurrent activities the techniques used in the design and implementation of operating systems would better suit our requirements. It is shown that using the basic concepts of concurrency and their implementation can lead to the design of a general real-time scheduler which solves this and other related problems as well.
A historical perspective for teaching
Authors: Shiflet Angela B.
Published: July 2004

A historical perspective in a computer science or mathematics course can help to make the class more interesting as well as help to provide an understanding of the evolution of the subject. Several anecdotes that can be used in teaching such courses will be covered in this paper.
Let's motivate]
Authors: Tharp Alan L.
Published: July 2004

Few endeavors are successful without the proper preparation. For students to learn successfully, they must be prepared for the task; they must be motivated. In the past, much of this motivation has come from sources beyond the classroom. The instructor has had to do little to motivate the students as long as he did not discourage them. Those external motivational factors are not as prominent as they once were and this circumstance places more of the responsibility for motivating the students on the instructor. This paper, which suggests procedures for motivating students, is intended to emphasize the importance of motivation in learning and to foster an awareness of it. The paper also notes the need for greater recognition for those who provide the motivation, that is, the instructors.
Teaching digital hardware by using complex lab projects
Authors: Prosser Franklin , Winkel David
Published: July 2004

Indiana University's Department of Computer Science teaches digital hardware organization and design as a two-semester course sequence at the senior/graduate level. The courses are four credit hours each and have classroom and laboratory components. Our goals have been to provide a firm foundation of theoretical and practical knowledge of digital hardware so that our graduates can understand electronic devices, design digital hardware, and work effectively on large projects with engineers, scientists, and managers.

In the laboratory our students confront a small number of large and complex problems, with few or no small-scale isolated experiments. This philosophy is consistent with the approach usually taken in the software areas of our curriculum—to try as best we can to teach the student to cope with the complex issues found in real-world problem-solving. Achieving this goal in the digital hardware instructional laboratory requires a substantial commitment of funds and faculty and staff effort.
A multi-purpose language processing laboratory
Authors: Lemone Karen A.
Published: July 2004

This paper describes the design and implementation of a tool for creating language processors, in particular, translator generators. The purpose of this tool is to allow the fast implementation of (non-production quality) translators for any language, however exotic, for which a grammar can be written, and to generate compiler phases with “hooks” which show the compiling process in action for use in compiler construction courses. The emphasis is on a user-friendly metalanguage which is consistent for the various phases of the parameterized tool. Use of the tool in a graduate compiler construction course revealed the strengths of this metalanguage as well as providing a test site for other improvements and further development of the tool.
An industrial advisory council for a computer science department: a case study
Authors: Ballew David
Published: July 2004

This paper defines the need for an Industrial Advisory Council for a Computer Science Department and describes how such a Council can benefit the Department in its construction and updating of curriculum, in faculty and student development, in its relationship with the college or university administration and in its work with industry recruiters and management. The paper gives the details of a working Industrial Advisory Council and explains how the Council has actually helped with the items listed above.

The Council described functioned for three years while the author was Head of the Department at the South Dakota School of Mines and Technology. The author now has a new position at Western Illinois University and the paper describes the formation of a new Council at that University.
A scheduling problem: modeling, approximate algorithms, and implementation
Authors: Holliday Robert L. , Carmony Lowell A.
Published: July 2004

Beginning students tend to think that computer science means only programming. As teachers of computer science, we are constantly trying to emphasize that the important component of computer science is a problem solving ability. This is not easy for several reasons. First of all, it is difficult to “teach” problem solving, whether in the context of computer science or not. Secondly, beginning computer students spend the vast majority of their time struggling to get this program working just before the deadline so that they can then start on the next program. A third reason that students might miss the problem solving focus is that we don't give them enough opportunities to solve problems from start to finish. All too often these programming assignments are presented to the students in a “ready-to-program” format. That is, the real work is glossed over or is accomplished for them. In this paper we discuss a simple but important application, committee scheduling. This problem is an excellent example of the entire problem solving process and provides students at all levels with the opportunity to formulate a mathematical model, prove a theorem, consider alternate strategies for implementing a solution as a computer algorithm, and perform some elementary algorithm analysis.
IS and MIS: a compromise?
Authors: Unger Elizabeth A. , Hassett Charles M. , Castro Constanza
Published: July 2004

The information manager today is usually educated in a college of business with curriculum requirements guided by the DPMA guidelines for the management information systems, MIS, degree or in a computer science department with curriculum requirements guided by the ACM curriculum for information systems. There is considerable feedback to educators that such people although talented and well trained have enough flat sides in their background to make it necessary to expend considerable resources to make them useful to the organization as a well rounded and well grounded information analyst or manager. The complaint is heard that the MIS types are not technically oriented enough and the IS types are not management oriented enough. The authors undertook a study of the complaints, the suggestions, the current curriculum guidelines and the existing programs. Out of this study emerged a proposal for a degree which blends the current ACM and DPMA guidelines, adds new requirements and suggests different teaching methodologies. The proposal has the potential to address many of the current deficiencies perceived by employers of MIS and IS graduates but it has other problems including acceptance within a traditionally organized and funded university. This paper addresses our solution, its merits, and shortcomings.
Trends in hardware and software usage in introductory database courses
Authors: Pierson J. K. , Shorter Jack D.
Published: July 2004

A survey of business schools accredited by the Assembly of American Collegiate Schools of Business has provided data on the hardware and software used in introductory database courses. Survey results show that the size computer used most often in the course is the microcomputer, followed in popularity by upper-end minicomputers. Relational database management software is used in preference over hierarchical and network DBMS.
Goals for and lessons from a computer literacy course
Authors: Peterson John T.
Published: July 2004

The primary component of most computer literacy courses has been learning to use a computer. However, a detailed treatment of societal issues, including the view of humans as machines, is equally important. Some difficulties of implementing a literacy course are also discussed.
A modular approach to program visualization in computer science instruction
Authors: Stone Don C.
Published: July 2004

The approach to program visualization in computer science instruction discussed here has two components: the graphic display of algorithms and the graphic display of their execution. Both types of display are based on the same hierarchical representation of an algorithm (in terms of Scandura FLOWforms, an enhancement and generalization of Nassi-Shneiderman diagrams). The execution display is obtained by the addition of explicit display commands to the basic algorithm, but the execution display details can be largely suppressed when the algorithm itself is being displayed. Two major characteristics of this approach are the modularity and the easy modifiability of demonstration procedures. The hardware required is an IBM PC or AT or compatible.
Student-oriented features of an interactive programming environment
Authors: Fisher Gene
Published: July 2004

This paper describes features of a program development environment of particular use for student programmers. The environment contains tools for both textual and graphical program development. The textual tools include those now commonly found in interactive programming environments: interactive interpreter, language-based editor, debugger. The tools are provided for four languages in the “Pascal family:” Pascal, C, Modula-2 and Fortran. An important student-oriented feature of the environment is the capability for rapid switching between languages, allowing features in different languages to be compared side by side. The environment also provides a graphical program interface that students may use to test their programs interactively. The graphical interface is based on the notion of the
control panel
, through which students may interact with gauges and knobs to view and animate program data structures and output.
A component and communication model for push systems
Authors: Hauswirth Manfred , Jazayeri Mehdi
Published: July 2004

We present a communication and component model for push systems. Surprisingly, despite the widespread use of many push services on the Internet, no such models exist. Our communication model contrasts push systems with client-server and event-based systems. Our component model provides a basis for comparison and evaluation of different push systems and their design alternatives. We compare several prominent push systems using our component model. The component model consists of producers and consumers, broadcasters and channels, and a transport system. We detail the concerns of each of these components. Finally, we discuss a number of open issues that challenge the widespread deployment of push or any other system on an Internet-wide scale. Payment models are the most important among these and are not adequately addressed by any existing system. We briefly present the payment approach in our Minstrel project.
Specification-based prototyping for embedded systems
Authors: Thompson Jeffrey M. , Heimdahl Mats P. E. , Miller Steven P.
Published: July 2004

Specification of software for safety critical, embedded computer systems has been widely addressed in literature. To achieve the high level of confidence in a specification's correctness necessary in many applications, manual inspections, formal verification, and simulation must be used in concert. Researchers have successfully addressed issues in inspection and verification; however, results in the areas of execution and simulation of specifications have not made as large an impact as desired.

In this paper we present an approach to
specification-based prototyping
which addresses this issue. It combines the advantages of rigorous formal specifications and rapid systems prototyping. The approach lets us refine a formal executable model of the system requirements to a detailed model of the software requirements. Throughout this refinement process, the specification is used as a prototype of the proposed software. Thus, we guarantee that the formal specification of the system is always consistent with the observed behavior of the prototype. The approach is supported with the NIMBUS environment, a framework that allows the formal specification to execute while interacting with software models of its embedding environment or even the physical environment itself (hardware-in-the-loop simulation).
Coping with type casts in C
Authors: Siff Michael , Chandra Satish , Ball Thomas , Kunchithapadam Krishna , Reps Thomas
Published: July 2004

The use of type casts is pervasive in C. Although casts provide great flexibility in writing programs, their use obscures the meaning of programs, and can present obstacles during maintenance. Casts involving pointers to structures (C structs) are particularly problematic, because by using them, a programmer can interpret any memory region to be of any desired type, thereby compromising C's already weak type system.

This paper presents an approach for making sense of such casts, in terms of understanding their purpose and identifying fragile code. We base our approach on the observation that casts are often used to simulate object-oriented language features not supported directly in C. We first describe a variety of ways —
idioms
— in which this is done in C programs. We then develop a notion of
physical subtyping
, which provides a model that explains these idioms.

We have created tools that automatically analyze casts appearing in C programs. Experimental evidence collected by using these tools on a large amount of C code (over a million lines) shows that, of the casts involving struct types, most (over 90%) can be associated meaningfully — and automatically — with physical subtyping. Our results indicate that the idea of physical subtyping is useful in coping with casts and can lead to valuable software productivity tools.
An efficient relevant slicing method for debugging
Authors: Gyimóthy Tibor , Beszédes Árpád , Forgács Istán
Published: July 2004

Dynamic program slicing methods are widely used for debugging, because many statements can be ignored in the process of localizing a bug. A dynamic program slice with respect to a variable contains only those statements that actually had an influence on this variable. However, during debugging we also need to identify those statements that actually did not affect the variable but could have affected it had they been evaluated differently. A relevant slice includes these potentially affecting statements as well, therefore it is appropriate for debugging. In this paper a forward algorithm is introduced for the computation of relevant slices of programs. The space requirement of this method does not depend on the number of different dynamic slices nor on the size of the execution history, hence it can be applied for real size applications.
An efficient algorithm for computing
MHP
information for concurrent Java programs
Authors: Naumovich Gleb , Avrunin George S. , Clarke Lori A.
Published: July 2004

Information about which statements in a concurrent program may happen in parallel (
MHP
) has a number of important applications. It can be used in program optimization, debugging, program understanding tools, improving the accuracy of data flow approaches, and detecting synchronization anomalies, such as data races. In this paper we propose a data flow algorithm for computing a conservative estimate of the
MHP
information for Java programs that has a worst-case time bound that is cubic in the size of the program. We present a preliminary experimental comparison between our algorithm and a reachability analysis algorithm that determines the “ideal” static
MHP
information for concurrent Java programs. This initial experiment indicates that our data flow algorithm precisely computed the ideal
MHP
information in the vast majority of cases we examined. In the two out of 29 cases where the
MHP
algorithm turned out to be less than ideally precise, the number of spurious pairs was small compared to the total number of ideal
MHP
pairs.
The CIP method
Authors: Fierz Hugo
Published: July 2004

CIP is a model-based software development method for embedded systems. The problem of constructing an embedded system is decomposed into a
functional
and a
connection
problem. The
functional
problem is solved by constructing a formal reactive behavioural model. A CIP model consists of concurrent clusters of synchronously cooperating extended state machines. The state machines of a cluster interact by multi-cast events. State machines of different clusters can communicate through asynchronous channels. The construction of CIP models is supported by the CIP Tool, a graphical modelling framework with code generators that transform CIP models into concurrently executable CIP components. The
connection
problem consists of connecting generated CIP components to the real environment. This problem is solved by means of techniques and tools adapted to the technology of the interface devices. Construction of a CIP model starts from the behaviour of the processes of the real environment, leading to an operational specification of the system behaviour in constructive steps. This approach allows stable interfaces of CIP components to be specified at an early stage, thus supporting concurrent development of their connection to the environment.
Consistency checking for multiple view software architectures
Authors: Fradet Pascal , Le Métayer Daniel , Périn Michaël
Published: July 2004

Consistency is a major issue that must be properly addressed when considering multiple view architectures. In this paper, we provide a formal definition of views expressed graphically using diagrams with multiplicities and propose a simple algorithm to check the consistency of diagrams. We also put forward a simple language of constraints to express more precise (intra-view and inter-view) consistency requirements. We sketch a complete decision procedure to decide whether diagrams satisfy a given constraint expressed in this language. Our framework is illustrated with excerpts of a case study: the specification of the architecture of a train control system.
Synergy between component-based and generative approaches
Authors: Jarzabek Stan , Knauber Peter
Published: July 2004

Building software systems out of pre-fabricated components is a very attractive vision. Distributed Component Platforms (DCP) and their visual development environments bring this vision closer to reality than ever. At the same time, some experiences with component libraries warn us about potential problems that arise in case of software system families or systems that evolve over many years of changes. Indeed, implementation level components, when affected by many independent changes, tend to grow in both size and number, impeding reuse. In this paper, we analyze in detail this effect and propose a program construction environment, based on generative techniques, to help in customization and evolution of component-based systems. This solution allows us to reap benefits of DCPs during runtime and, at the same time, keep components under control during system construction and evolution. In the paper, we describe such a construction environment for component-based systems that we built with a commercial generator and illustrate its features with examples from our domain engineering project. The main lesson learnt from our project is that generative techniques can extend the strengths of the component-based approach in two important ways: Firstly, generative techniques automate routine component customization and composition tasks and allow developers work more productively, at a higher abstraction level. Secondly, as custom components with required properties are generated on demand, we do not need to store and manage multiple versions of components, components do not overly grow in size, helping developers keep the complexity of an evolving system under control.
Verification of real-time designs
Authors: Braberman Victor A. , Felder Miguel
Published: July 2004

We present an automatic approach to verify designs of real-time distributed systems for complex timing requirements. We focus our analysis on designs which adhere to the hypothesis of analytical theory for Fixed-Priority scheduling. Unlike previous formal approaches, we draw from that theory and build small formal models (based on Timed Automata) to be analyzed by means of model checking tools. We are thus integrating scheduling analysis into the framework of automatic formal verification.
Checking progress with action priority
Authors: Giannakopoulou Dimitra , Magee Jeff , Kramer Jeff
Published: July 2004

The liveness characteristics of a system are intimately related to the notion of fairness. However, the task of explicitly modelling fairness constraints is complicated in practice. To address this issue, we propose to check LTS (Labelled Transition System) models under a strong fairness assumption, which can be relaxed with the use of action priority. The combination of the two provides a novel and practical way of dealing with fairness. The approach is presented in the context of a class of liveness properties termed
progress
, for which it yields an efficient model-checking algorithm. Progress properties cover a wide range of interesting properties of systems, while presenting a clear intuitive meaning to users.
Increasing visualization and interaction in the automata theory course
Authors: Hung Ted , Rodger Susan H.
Published: July 2004

In this paper we describe how to increase the visualization and interaction in the automata theory course through the use of the tools JFLAP and Pâté. We also describe new features in these tools that allow additional visualization and interaction. New features in JFLAP include the addition of regular expressions and exploring their conversion from and to nondeterministic finite automata (NFA), and increasing the interaction in the conversion of automata to grammars. New features in Pâté include the display of a parse tree while parsing unrestricted grammars, and improved interaction with parsing and the transformation of grammars.
CUPV—a visualization tool for generated parsers
Authors: Kaplan Alan , Shoup Denise
Published: July 2004

Compiler projects frequently use parser generators to help students design and construct non-trivial translators. Unfortunately, the code and data structures produced by such generators, and hence the overall parser, can be difficult to understand and debug. In this paper, we present an extendible and flexible tool for visualizing the operation of generated parsers. The objective of this tool is to provide students with a deeper understanding of parsing algorithms, data structures and techniques.
Design patterns for lazy evaluation
Authors: Nguyen Dung , Wong Stephen B.
Published: July 2004

We propose an object-oriented (OO) formulation and implementation of lazy/delayed evaluation by reusing and extending an existing linear recursive structure (LRS) framework with the help of the strategy, decorator and factory design patters. The result is a robust, flexible framework that can handle both infinite and finite lists and to which existing algorithms for finite lists can be applied without modification. The OO techniques used to develop this model are effective tools for teaching abstraction and design of data structures.
The next decade of the database course
Authors: Springsteel Frederick , Robbert Mary Ann , Ricardo Catherine M.
Published: July 2004

Last year at SIGCSE'99, for the first time in recent memory, a Birds-of-Feather (BOF) session for Database educators was held. As some attendees noted, there had not been a Database education paper accepted for that or the previous SIGCSE meetings, although there had been three @@@@ 1997 [12]. From about two dozen educators, “meta-data” or data about many aspects of their courses were discovered. Few had paid any attention to ACM/IEEE's curriculum '91 when designing their courses to fit late-century students' needs. This expository paper examines, first, what was the state of the Database course near the end of the 20
th
century, as background to a discussion of what should or
will be the near-term
future of the (first, undergraduate) Database course. From data gathered mostly at the BOF and some later by email, we found the following “state of the course,” 1998-99.
Curriculum development in Internet and multimedia technology
Authors: Sorkin Sylvia , Mento Barbara , Tupper Donna , Harmeyer Kathleen
Published: July 2004

Employers in business, entertainment, and education seek employees to help them meet the demands for web-based interactive technologies. This paper describes a thirty-credit, community college certificate program in Internet and Multimedia Technology (I/MMT), and plans to expand it to an associate's degree program. Detailed descriptions of two courses, Multimedia Authoring I and Internet Programming, central to the program are provided. The program immerses students in a technology-rich environment for their general education courses, and provides internships with local multimedia and web firms.
“Alfonse, you have a message!”
Authors: Hartley Stephen J.
Published: July 2004

Synchronization of multiple threads in a Java program using the built-in features of the language has serious pitfalls for the programmer, particularly if a thread is interrupted while waiting inside a monitor. These concerns have lead to a movement to avoid Java monitors altogether and use message passing instead. This paper visits the field of concurrent programming to show that replacing all Java monitors with message passing is an overreaction to these problems.
Teaching parallel algorithm with process topologies
Authors: McDonald Chris , Kazemi Kamran
Published: July 2004

Parallel algorithms are often introduced to students by describing the geometric topologies formed by communicating processes and often the geographic relationships between them. However, the two most common message passing environments used in teaching, PVM and MPI, each provide only rudimentary support for the specification and execution of process topologies. There is a strong need for better syntactic and semantic support for process topologies in these environments, so that students may concentrate on the algorithms being studied, and not have to wrestle with the environments' infrastructure. This paper first motivates, and then describes the use of additional support within PVM and MPI which addresses this need.
Programming patterns and design patterns in the introductory computer science course
Authors: Proulx Viera K.
Published: July 2004

We look at the essential thinking skills students need to learn in the introductory computer science course based on object-oriented programming. We create a framework for such a course based on the elementary programming and design patterns. Some of these patterns are known in the pattern community, others enrich the collection. Our goal is to help students focus on mastering reasoning and design skills before the language idiosynchracies muddy the water.