bluuebunny/crossref_metadata_2025 huggingface dataset:
PM
Authors: Zhou Wanlei
Published: July 2004

The design and implementation of a software tool PM for prototyping and monitoring remote procedure call (RPC) programs is described. The tool has two parts: a prototyping generator and a monitor. The
prototyping generator
takes as input several server description files, one for each server, analyses them, and produces a group of source files of the RPC prototype program. If debug option is chosen during prototyping, the produced programs will be monitored by the
monitor
. The monitor records all events of an RPC-based program into the monitor's database. Facilities are provided for programmers to define, choose, and combine events that will be recorded. Partial ordering among events is built after the program's execution. An user can use this relation to trace and replay the program's execution. The tool forms a proper environment for RPC-based program development.
Code reusability in the large versus code reusability in the small
Authors: Lubars Mitchell D.
Published: July 2004

As a general rule, the goals of software engineering involve the development of techniques for improving software development productivity. It is no surprise, then, that a lot of attention has been focused on facilitating the reuse of program code. However, most of this attention has been directed with only shortsighted and self-supporting goals, and has thus condemned code reuse techniques to limited areas of success. This paper brings to light some of the issues involving code reusability, which include technical, social, economic, and psychological considerations. Code reusability "in the large" is contrasted with code reusability "in the small," and methods for improving code reusability are examined.
YAATCE—yet another approach to teaching computer ethics
Authors: Wahl Nancy J.
Published: July 2004

Two events have encouraged computer science departments to incorporate ethical issues and professional responsibilities into their curriculum. The first was the formation of the Computer Sciences Accreditation Board (CSAB) and the second was the publication of Computing Curricula 1991. In the CSAB criteria for accrediting programs in computer science [2], is the requirement that social and ethical implications of computing be included in computer science programs. The Computing Curricula 1991 states that "students must understand the basic cultural, social, legal and ethical issues inherent in ... computing" [7]. This article contains a description of one approach to teaching the social, ethical and legal implications of computing.
Using randomization in the teaching of data structures and algorithms
Authors: Goodrich Michael T. , Tamassia Roberto
Published: July 2004

We describe an approach for incorporating randomization in the teaching of data structures and algorithms. The proofs we include are quite simple and can easily be made a part of a Freshman-Sophomore Introduction to Data Structures (CS2) course and a Junior-Senior level course on the design and analysis of data structures and algorithms (CS7/DS&A). The main idea of this approach is to show that using randomization in data structures and algorithms is safe and can be used to significantly simplify efficient solutions to various computational problems. We illustrate this approach by giving examples of the use of randomization in some traditional topics from CS2 and DS&A.
Incorporating the client's role in a software engineering course
Authors: Polack-Wahl Jennifer A.
Published: July 2004

In today's society it is important for graduates of the computer science/information system programs to be able to interact with clients effectively. Students need to understand how a client feels and acts during the development of a software system. This paper describes the organization, motive, and experience with an Application Development Course that addresses these issues.
Computer network management
Authors: Elenbogen Bruce S.
Published: July 2004

This paper discusses a non-traditional course in computer networking. The course is a laboratory course with substantial hands-on experiences, which can help to prepare students for jobs in industry as soon as they graduate from an undergraduate institution. This course is not meant to replace the traditional network course but to supplement it by teaching how computer networks work in practice and by exploring new topics such as internetworking, high speed networking, client/server computing and security.
An inductive approach to teaching object-oriented design
Authors: McCracken Daniel D.
Published: July 2004

An approach is described in which students learn object-oriented design by using as many of the characteristics of real program development (starting with incomplete specifications, etc.) as possible in a one-month project. Two-person teams are used, both for the benefit of team experience and to divide the effort between an algorithm portion and a GUI portion. Examples of student work are given, together with suggestions for other projects. Ideas for running a project are given in a week-by-week listing. The paper ends with suggestions for grading.
Computer science curriculum assessment
Authors: McDonald Merry , McDonald Gary
Published: July 2004

In this paper, we describe a comprehensive computer science curriculum assessment and improvement process that has been implemented at Northwest Missouri State University.
Testers and visualizers for teaching data structures
Authors: Baker Ryan S. , Boilen Michael , Goodrich Michael T. , Tamassia Roberto , Stibel B. Aaron
Published: July 2004

We present two tools to support the teaching of data structures and algorithms:
Visualizers
, which provide interactive visualizations of user-written data structures, and
Testers
, which check the functionality of user-written data structures. We outline a prototype implementation of visualizers and testers for data structures written in Java, and report on classroom use of testers and visualizers in an introductory Data Structures and Algorithms (CS2) course.
Granularity in the design of interactive illustrations
Authors: Gould Daniel L. , Simpson Rosemary M. , van Dam Andries
Published: July 2004

We describe some issues in designing and building educational Java applets for an introductory computer graphics course. The design problem involves balancing educational goals of building intuition about fundamental concepts in a domain against heterogeneity both in subject material and in student backgrounds. We present our design approach for resolving these forces --- fine-grained units addressing small concepts --- and discuss its effects on other areas including hypertext structure, interface design, and software engineering.
Current issues in undergraduate student research
Authors: Sobel Ann E. Kelley , Guimaraes Mario
Published: July 2004

This panel proposal outlines the need, and significance of evaluating formal presentations of an undergraduate student's current research for the ACM International Student Research Poster Contest.
The networks course
Authors: Akhtar Shakil , Al-Holou Nizar , Fienup Mark , Finley Gail T. , Roos Robert S. , Tannouri Sam
Published: July 2004

New approaches and techniques for teaching the undergraduate level course in networks and data communications will be discussed. Many of these ideas were presented at the 1998 Workshop on Networking sponsored by NSF and Michigan State University's Department of Computer Science and Engineering.
DPLab
Authors: Ben-Ari Mordechai , Silverman Shawn
Published: July 2004

This paper describes the software package DPLab which implements an integrated GUI environment for developing distributed programs. The environment includes a text editor, a compiler, and a runtime system that establishes communications between networked computers and provides primitives for message passing between the computers. The source language is Pascal extended with these primitives and with constructs for concurrent programming. The package is implemented in Java and Swing for portability.
Teaching computer architecture with a new superscalar processor emulator
Authors: de la Fuente Santiago Rodríguez , Clemente M. Isabel García , Cavanillas Rafael Méndez
Published: July 2004

Current computers use several techniques to improve performance such as cache memories, pipeline and multiple instruction issue per cycle. Using a real computer to teach these concepts is actually impractical, because these computers are designed to be programmed in high-level languages.In order to solve this problem, we have implemented a superscalar processor emulator, where most of the processor and cache parameters can be defined by the student. Its objective is to create a set of laboratory works allowing the student to observe how the different components of the computer evolve while executing an assembler program. It allows detection of the different kinds of cache misses and hazards as well as their impact on performance. Then, the student can apply some software techniques to reduce cache misses and to avoid hazards.
A collaborative learning trial between New Zealand and Sweden-using Lotus Notes Domino in teaching the concepts of Human Computer Interaction
Authors: Clear A. G.(Tony)
Published: July 2004

This paper reports the results of a collaborative learning exercise between students at Auckland Institute of Technology and Uppsala University. The exercise was conducted using both a Lotus Notes Domino™ collaborative database and electronic mail to support students working in remote groups to perform a common task. Issues concerning the logistics of such an exercise, student participation and evaluations of the process, ethical considerations and the quality of the learning process are discussed. Some conclusions are drawn concerning the value of Group Ware technology to support this form of collaborative learning, and suggestions are made for future developments.
The University in the inner city
Authors: Boyle Roger , Roberts Ann
Published: July 2004

The traditional university often has a world class reputation for teaching and research. Equally often it is centrally sited in established cities through which the winds of economic change have blown viciously, leaving ivory towers surrounded by neighbourhoods of underprivileged communities. Within these communities, junior and high schools do their best to battle against under-motivation and lack of expectation in the literal shadow of elaborately resourced institutions populated by secure and highly educated staff, teaching students from more affluent backgrounds who look forward on graduation to similar levels of security in employment.For modest investment, we demonstrate that it is possible to bridge the gap between these two communities. An exercise which commenced as a tightly funded service to a small number of inner-city schools has grown to serve a larger number. Of more interest, it has demonstrated the potential to be of direct benefit to a range of students of the university in a way that could not otherwise be provided.
Designing courseware on algorithms for active learning with virtual board games
Authors: Faltin Nils
Published: July 2004

We present a method for designing courseware on algorithms for active learning with virtual board games. Our goal is to build algorithm courseware that integrates explanation with animation and makes the student an active participant. We give hints for structuring the material into sections and mixing presentation with exercises. We present our ideas for a new form of visual interactive exercise and a cardboard game prototype with which we tested our ideas.
Multi-team development project experience in a core computer science curriculum
Authors: Kubilus Norbert J.
Published: July 2004

This paper discusses our introducing a multi-team development project into the third semester of an undergraduate Computer Science core curriculum. One of the goals of the third semester course has been to provide student with practical experience in system design and development. The multi-team development project exposes students to the rigors of working together to complete a specific component of a larger system and to insure that all components integrate properly. It also introduces them to project management concepts such as project scheduling, maintaining team journals, delivering written and oral team status reports, and participating in project meetings.
The implementation of a data communications laboratory in small to medium sized universities
Authors: Levin Martin H.
Published: July 2004

This poster describes techniques for establishing a Data Communications Laboratory in the small to mid-sized university. The experience for the poster was gained in the building of a lab funded by a NSF-ILI grant.. We provide a tactical approach to the lab and a discussion of the physical environment and basic equipment requirements. Special interest is devoted to sources of assistance for equipment procurement, as well as how to lower both hardware and software costs. Included are the capabilities of the suggested lab for teaching the major network operating systems. The security aspects required by the laboratory are also covered.The type of Data Communications Laboratory described in the poster can be established with a minimum of funds and using excess or donated equipment. It will provide students some hands-on experience with data communications and establish the lab as a reality from which to expand to ever changing technologies. One secret of success in this effort is to make the establishment of a lab, a rallying point between the Faculty, students and university's Instructional Technology Department. Students should be involved in all steps of the planning and installation. The students involved with the project will be happy to be taking part in an effort that will add an effective hands-on approach to their data communications courses.
Campus-based industrial software projects
Authors: Parker Helen , Holcombe Mike
Published: July 2004

The involvement of commercial companies as clients in software engineering project work adds a new dimension to our students' education, developing the communication, team-working and managerial skills demanded by employers, [1]. Commercial collaboration introduces risks into course work which, like the risks in any commercial software project, must be controlled if the outcomes for all parties are to count as a success.
The system of checking students' knowledge with the use of wide area networks
Authors: Put Dariusz , Stal Janusz , Zurowicz Marek
Published: July 2004

In the situation when computers, and primarily wide area computer networks, are easily accessible, it is possible to conduct examinations with no need for the examinee and the examiner to be in the same place at the same time. This paper suggests how to carry out this postulate.
KPPCDL
Authors: Rossi Alfred J.
Published: July 2004

The Karel++ Collaborative Laboratory is an Internet based educational tool, which facilitates the learning of Object-Oriented programming techniques, by providing a shared development environment for the building of student programs written in the Karel++ language. KPPCDL offers remote sharing of Karel++ program elements, collaborative source code editing, textual and graphical notification of both coarse and finely grained remote updates, remote and local views of developing program elements, updated views for late comers, background source parsing, and real-time memo sending. The system combines features of both centralized and replicated architectures, and provides for both synchronous and asynchronous collaboration.
An exercise in evaluating significance of software quality criteria
Authors: Szejko Stanisław
Published: July 2004

The paper presents an exercise in mapping user requirements to software quality model in order to disclose the product quality characteristics the developer should take special care of. House of Quality of the Quality Function Deployment method [1,2] has been adapted for dealing with system requirements.
Designer—a logic diagram design tool
Authors: Power Chris
Published: July 2004

Designer
is a software tool that helps the program developer lay out structure diagrams. Structure diagramming is a structured design technique commonly taught in New Zealand polytechnics. Diagrams can be written for overall logic flow or detailed design. Unlike a flow chart, a structure diagram can always be directly translated to the control structures of a structured programming language. The basic diagram symbols are process boxes, decisions, loops, input-output boxes and procedure calls.
GNOME
Authors: Garlan David B. , Miller Philip L.
Published: July 2004

Structure editors have frequently been used as powerful and unifying interfaces for programming environments in computer science research settings. Few, however, have found their way into common use. GNOME is an attempt to channel the experience gained in the use of structure editing for software development environment research of the Gandalf Project into a practical novice programming environment. Based on a
family
of structure editors, it is currently being used to teach programming to undergraduates at Carnegie-Mellon University. This paper describes the GNOME environment, recounts lessons learned in adapting structure editors to novice programmers, and discusses its effectiveness as a teaching environment.
US&R
Authors: Vitter Jeffrey Scott
Published: July 2004

US&R (which stands for
Undo, Skip, & Redo
) is a new interactive approach to user recovery that offers significant advantages over current Undo/Redo packages. In the US&R package, a SKIP or REDO command may be ambiguous, in which case US&R enumerates the logical interpretations of the command and prompts the user both textually and graphically for the desired choice. US&R also allows new commands to be executed during the redo process. With US&R, novices can perform recoveries that might be difficult or impossible to do with other systems; experienced users can take even greater advantage of its functionality. US&R's data structure organizes the recovery information in a natural tree-like fashion that is easy to implement in a variety of interactive settings, including text editors, graphics layout systems, algorithm simulators, and program development systems.
Gypsy
Authors: Ambler Allen L. , Good Donald I. , Browne James C. , Burger Wilhelm F. , Cohen Richard M. , Hoch Charles G. , Wells Robert E.
Published: July 2004

An introduction to the Gypsy programming and specification language is given. Gypsy is a high-level programming language with facilities for general programming and also for systems programming that is oriented toward communications processing. This includes facilities for concurrent processes and process synchronization. Gypsy also contains facilities for detecting and processing errors that are due to the actual running of the program in an imperfect environment. The specification facilities give a precise way of expressing the desired properties of the Gypsy programs. All of the features of Gypsy are fully verifiable, either by formal proof or by validation at run time. An overview of the language design and a detailed example program are given.
Static determination of dynamic properties of generalized type unions
Authors: Cousot Patrick , Cousot Radhia
Published: July 2004

The classical programming languages such as PASCAL or ALGOL 68 do not provide full data type security. Run-time errors are not precluded on basic operations. Type safety necessitates a refinement of the data type notion which allows subtypes. The compiler must also be able to ensure that basic operations are applicable. This verification consists in determining a local subtype of globally declared variables or constants. This may be achieved by improved compiler capabilities to analyze the program properties or by language constructs which permit the expression of these properties. Both approaches are discussed and illustrated by the problems of access to records via pointers, access to variants of record structures, determination of disjoint collections of linked records, and determination of integer subrange. Both approaches are complementary and a balance must be found between what must be specified by the programmer and what must be discovered by the compiler.
Towards a discipline of real-time programming
Authors: Wirth N.
Published: July 2004

Programming is divided into three major categories with increasing complexity of reasoning in program validation: sequential programming,
multi
-programming, and
real-time
programming. By adhering to a strict programming
discipline
and by using a suitable high-level
language
molded after this discipline, we may drastically reduce the complexity of reasoning about concurrency and execution time constraints. This may be the only practical way to make real-time systems analytically verifyable and ultimately reliable. A possible discipline is outlined and expressed in terms of the language
Modula
.
A microprocessor development environment based on the Amsterdam compiler kit, EMACS and UNIX
Authors: Gray David F.
Published: July 2004

This note describes a microprocessor development environment (MDE) that meets both the public educational sectors technical requirements and the constraints of low-cost, flexibility and maintainability.The individual parts of the system described are available in the public domain, via the academic community or available commercially at low cost. Each item is either obtainable in either source code form or is provided with an accompanying configuration system to allow tailoring to specific requirements.
An operating system project using Concurrent Euclid
Authors: Grit Dale H.
Published: July 2004

For the past four years, the senior level operating systems course at Colorado State University has been using a project to reinforce the lecture material. The project used is essentially the project described in Shaw[l], and is implemented using Concurrent Euclid. In this paper, we will: provide an overview of the project; introduce the Concurrent Euclid language, emphasizing those aspects that make it a good choice to support this project; provide some details concerning the implementation of the project; and discuss student reactions to the project.
An architecture for flexible, evolvable process-driven user-guidance environments
Authors: Sliski Timothy J. , Billmers Matthew P. , Clarke Lori A. , Osterweil Leon J.
Published: July 2004

Complex toolsets can be difficult to use. User interfaces can help by guiding users through the alternative choices that might be possible at any given time, but this tends to lock users into the fixed interaction models dictated by the user-interface designers. Alternatively, we propose an approach where the tool utilization model is specified by a process, written in a process definition langauge. Our approach incorporates a user-interface specification that describes how the user-interface is to respond to, or reflect, progress through the execution of the process definition. By not tightly binding the user-guidance process, the associated user-interfaces, and the toolset, it is easy to develop alternative processes that provide widely varying levels and styles of guidance and to be responsive to evolution in the processes, user interfaces, or toolset. In this paper, we describe this approach for developing process-driven user-guidance environments, a lossely coupled architecture for supporting this separation of concerns, and a generator for automatically binding the process and the user interface. We report on a case study using this approach. Although this case study used a specific process definition language and a specific toolset, the approach is applicable to other process definition languages and toolsets, provided they meet some basic, sound software engineering requirements.
The structure and value of modularity in software design
Authors: Sullivan Kevin J. , Griswold William G. , Cai Yuanfang , Hallen Ben
Published: July 2004

The concept of information hiding modularity is a cornerstone of modern software design thought, but its formulation remains casual and its emphasis on changeability is imperfectly related to the goal of creating added value in a given context. We need better explanatory and prescriptive models of the nature and value of information hiding. We evaluate the potential of a new theory---developed to account for the influence of modularity on the evolution of the computer industry---to inform software design. The theory uses
design structure matrices
to model designs and
real options
techniques to value them. To test the potential utility of the theory for software we apply it to Parnas's KWIC designs. We contribute an extension to design structure matrices, and we show that the options results are consistent with Parnas's conclusions. Our results suggest that such a theory does have potential to help inform software design.
Interface automata
Authors: de Alfaro Luca , Henzinger Thomas A.
Published: July 2004

Conventional type systems specify interfaces in terms of values and domains. We present a light-weight formalism that captures the
temporal
aspects of software component interfaces. Specifically, we use an automata-based language to capture both input assumptions about the order in which the methods of a component are called, and output guarantees about the order in which the component calls external methods. The formalism supports automatic compatability checks between interface models, and thus constitutes a type system for component interaction. Unlike traditional uses of automata, our formalism is based on an
optimistic
approach to composition, and on an
alternating
approach to design refinement. According to the optimistic approach, two components are compatible if there is
some
environment that can make them work together. According to the alternating approach, one interface refines another if it has weaker input assumptions, and stronger output guarantees. We show that these notions have game-theoretic foundations that lead to efficient algorithms for checking compatibility and refinement.
Using symbolic execution for verifying safety-critical systems
Authors: Coen-Porisini Alberto , Denaro Giovanni , Ghezzi Carlo , Pezzé Mauro
Published: July 2004

Safety critical systems require to be highly reliable and thus special care is taken when verifying them in order to increase the confidence in their behavior. This paper addresses the problem of formal verification of safety critical systems by providing empirical evidence of the practical applicability of symbolic execution and of its usefulness for checking safety-related properties. In this paper, symbolic execution is used for building an operational model of the software on which safety properties, expressed by means of a Path Description Language (PDL), can be assessed.
Behavioral contracts and behavioral subtyping
Authors: Findler Robert Bruce , Latendresse Mario , Felleisen Matthias
Published: July 2004

Component-based software manufacturing has the potential to bring division-of-labor benefits to the world of software engineering. In order to make a market of software components viable, however, producers and consumers must agree on enforceable software contracts. In this paper, we show how to enforce contracts if components are manufactured from class and interface hierarchies. In particular, we focus on one style of contract: pre- and post-conditions. Programmers annotate class and interface methods with pre- and post-conditions and the run-time system checks these conditions during evaluation. These contracts guarantee that methods are called properly and provide appropriate results. In procedural languages, the use of pre- and post-condition contracts is well-established and studies have demonstrated its value. In object-oriented languages, however, assigning blame for pre- and post-condition failures poses subtle and complex problems. Specifically, assigning blame for malformed class and interface hierarchies is so difficult that none of the existing contract monitoring tools correctly assign blame for these failures. In this paper, we show how to overcome these problems in the context of Java. Our work is based on the notion of behavioral subtyping.
Pursuing failure
Authors: Dickinson William , Leon David , Podgurski Andy
Published: July 2004

Observation-based testing calls for analyzing profiles of executions induced by potential test cases, in order to select a subset of executions to be checked for conformance to requirements. A family of techniques for selecting such a subset is evaluated experimentally. These techniques employ automatic cluster analysis to partition executions, and they use various sampling techniques to select executions from clusters. The experimental results support the hypothesis that with appropriate profiling, failures often have
unusual
profiles that are revealed by cluster analysis. The results also suggest that failures often form small clusters or chains in sparsely-populated areas of the profile space. A form of adaptive sampling called
failure-pursuit sampling
is proposed for revealing failures in such regions, and this sampling method is evaluated experimentally. The results suggest that failure-pursuit sampling is effective.
STG
Authors: Clarke Duncan , Jéron Thierry , Rusu Vlad , Zinovieva Elena
Published: July 2004

We report on a tool we have developed that automates the derivation of tests from specifications. The tool implements conformance testing techniques to derive symbolic tests that incorporate their own oracles from formal operational specifications. It was applied for testing a simple version of the CEPS (Common Electronic Purse Specification).
A formal data-model of the CORBA security service
Authors: Basin David , Rittinger Frank , Viganò Luca
Published: July 2004

We use the formal language Z to specify and analyze the security service of CORBA. In doing so, we tackle the problem of how one can apply lightweight formal methods to improve the precision and aid the analysis of a substantial, informal specification. Our approach is scenario-driven: we use representative scenarios to determine which parts of the informal specification should be formalized and then verify the formal specification against the requirements of these scenarios.
Fundamental concepts for practical software architecture
Authors: Ran Alexander
Published: July 2004

Architecture of software is a collection of design decisions that are expensive to change. How to identify which design decisions are expensive to change? What are architecture views and which views are needed to adequately describe the architecture of a specific system? How to create and manage software architecture for a product family? This tutorial offers answers to these and other questions that arise in the context of complex software development. We introduce a system of concepts useful in order to understand, design, and evaluate architecture of software intensive systems and system families. Our approach utilizes different software structures in order to control important system qualities related to its development, performance, and evolution. We draw our experience primarily from software embedded in voice and data communication systems. However the same principles can be applied to software architecture in other domains. This tutorial should be useful to engineers and technical managers involved in construction or evaluation of complex software.
Making sense of the bazaar
Authors: Feller Joseph , Fitzgerald Brian , van der Hoek André
Published: July 2004

Since the coining of the term "Open Source" in 1998, there has been a surge of academic and industrial research on the topic.

Making Sense of the Bazaar: 1
st
Workshop on Open Source Software Engineering

brought together 30 researchers and practitioners from 8 countries to discuss Open Source Software as an emerging Software Engineering paradigm. The full proceedings of the workshop have been made available online, and the full workshop report will be published in a special issue of
IEE Proceedings --- Software
on Open Source Software Engineering.
The SEMINAL workshop
Authors: Harman Mark , Jones Bryan F.
Published: July 2004

This paper reports on the first international Workshop on Software Engineering using Metaheuristic INnovative ALgorithms.The aim of the workshop was to bring together researchers in search-based metaheuristic techniques with researchers and practitioners in Software Engineering. The workshop sought to support and develop the embryonic community which straddles these two communities and which is working on the application of metaheuristic search-based techniques to problems in Software Engineering.The paper outlines the nature of the nascent field of Search-Based Software Engineering, and briefly outlines the papers presented at the workshop and the discussions which took place.
Viewing use cases as active objects
Authors: Zhang Lu , Xie Dan , Zou Wei
Published: July 2004

In this paper, we propose an idea of viewing use cases as active objects in the analysis model. Based on the idea, we present a new approach to use case-driven object-oriented analysis. This approach gives a systematic and natural way of incorporating use cases into the analysis model, and an effective way of localizing the effect of requirement changes.
Choosing a middleware for web-integration of a legacy application
Authors: Mondal Sakib Abdul , Gupta Kingshuk Das
Published: July 2004

Business applications today often face two contradictory constraints: they have to deal with heterogeneous platforms and at the same time meet the quality requirements. A larger number of middleware products are available to meet the first objective. An architect invariably faces a problem of picking up the right kind of middleware for the problem at hand. Fortunately, the second objective of quality requirements help an architect narrow down the choices of middleware. In this article, we demonstrate this fact through a project of web-integration of a legacy invoicing system.
Exchange format bibliography
Authors: Kienle Holger M.
Published: July 2004

This paper gives a brief bibliographical overview of exchange formats and related research areas. We classify exchange formats and try to give a brief assessment of the more interesting ones.
The cognitive flexibility theory0
Authors: Mendes Emilia , Mosley Nile , Counsell Steve
Published: July 2004

Hypermedia engineering constitutes the employment of an engineering approach to the development of hypermedia applications. Its main teaching objectives are for students to learn what an engineering approach means and how measurement can be applied.This paper presents the application of the Cognitive Flexibility Theory as an instructional theory to teach Hypermedia Engineering principles.Early results have shown that students presented a greater learning variability (suggested by their exam marks) when exposed to the CFT as a teaching practice, compared to conventional methods.
Teacing breadth-first depth-first
Authors: Murtagh Thomas P.
Published: July 2004

This paper argues that current approaches to teaching the introductory course for the CS major fail to provide students with an accurate sense of the nature of our field. We propose that an introductory course focused on a single sub-field of our discipline could better prepare potential majors by using that sub-field as a vehicle to present an overview of the techniques and principles fundamental to computer science. We discuss our experience with such a course based on the field of computer networks.
A cyber-icebreaker for an effective virtual group?
Authors: Clear Tony , Daniels Mats
Published: July 2004

This paper reports selected results from the most recent of a series of international collaborative trials between students at Auckland University of Technology and Uppsala University. The trials require students to work together in virtual groups, comprising students from each institution, to perform a common task. The topic of this paper is how to form and sustain more effective virtual groups. In this trial a cyber-icebreaker task has been introduced and its contribution to group effectiveness is explored. Some conclusions are drawn pinpointing the strengths and weaknesses of this trial design, and some insights into effective design of electronic collaborative learning groups are gained.
Fully automatic assessment of programming exercises
Authors: Saikkonen Riku , Malmi Lauri , Korhonen Ari
Published: July 2004

Automatic assessment of programming exercises has become an important method for grading students' exercises and giving feedback for them in mass courses. We describe a system called Scheme-robo, which has been designed for assessing programming exercises written in the functional programming language Scheme. The system assesses individual procedures instead of complete programs. In addition to checking the correctness of students' solutions the system provides many different tools for analysing other things in the program like its structure and running time, and possible plagiarism. The system has been in production use on our introductory programming course with some 300 students for two years with good results.
An open source laboratory for operating systems projects
Authors: Claypool Mark , Finkel David , Wills Craig
Published: July 2004

Typical undergraduate operating systems projects use services provided by an operating system via system calls or develop code in a simulated operating system. With the increasing popularity of operating systems with open source code such as Linux, there are untapped possibilities for operating systems projects to modify real operating system code. We present the hardware and software configuration of an open source laboratory that promises to provide students that use it with a better understanding of operating system internals than is typically gained in a traditional operating systems course. Our preliminary projects and evaluation suggest that thus far the lab has achieved its primary goal in that students that used the lab feel more knowledgeable in operating systems and more confident in their ability to write and modify operating system code.
Using a familiar package to demonstrate a difficult concept
Authors: Fone William
Published: July 2004

A course introducing neural networks to second year undergraduates with mixed disciplinary backgrounds needed a tool to reduce the overheads of simplifying the complex mathematical and programming skills normally associated with the subject. An Excel model was produced that had the added benefit of reducing anxiety, as all students taking the course are competent with Excel spreadsheets.
A first problem for the algorithms course (poster session)
Authors: Velázquez-Iturbide J. Á.
Published: July 2004

I present a problem to be used in the first class of the algorithms course as an introduction to the topic. Two algorithms are given, simple but rich enough to illustrate several issues.
Sneaking in extra material (panel session)
Authors: Joyce Daniel
Published: July 2004

Did you ever wish you could sneak some extra material into a course but it just doesn't fit with the syllabus and there's not enough time to add another unit to an already crowded calendar? In this Tips and Techniques I described how I snuck some computing history into an introductory programming course.
REFSQ '2001 workshop summary
Authors: Achour-Salinesi Camille Ben , Opdahl Andreas , Rossi Matti
Published: July 2004

The Seventh International Workshop on RE: Foundation for Software Quality (REFSQ'2001) was held in conjunction with CAiSE*01 in Interlaken, Switzerland on June 4th and 5th 2001. The workshop was organised by Camille Ben Achour - Salinesi, Andreas L. Opdahl and Matti Rossi, with Eric Dubois and Klaus Pohl serving on the REFSQ Advisory Board.This workshop summary gives an overview of the presentations and numerous fruitful discussions that took place at REFSQ'2001
Perspectives on Software Product Lines
Authors: Knauber Peter , Succi Giancarlo
Published: July 2004

Product line engineering is a recent concept and one of the hottest topics in software engineering aiming at synergy effects in software development. Diverse benefits like cost reduction, decreased time-to-market, and quality improvement can be expected from reuse of domain-specific software assets, several successful product line projects have been performed and documented [3]. Also non-technical benefits as result of network externalities, product branding, and sharing organizational costs have been observed.Following the remarkable success of the "First International Workshop on Software Product Lines: Economics, Architectures, and Implications" held at ICSE 2000 in Limerick [1], this second workshop stresses more the non-technical, that is, business and organizational aspects of product line adoption and institutionalization. Another major topic of interest are product line tools, as tool support seems to become more and more critical for the success of product line approaches. Different tool concepts have been proposed and discussed during the workshop. Requirements for tools and respective solutions seem to become more concrete, maybe resulting from the fact that the technical concepts and solutions of product line approaches are better understood and can therefore be better supported with tools.The strong emphasis on establishing contacts and giving experts and practitioners from academia and industry a platform for discussion has been continued during this second workshop.Section 2 of this workshop summary describes the formal structure of the workshop. In Section 3, a short summary of the invited talk on issues and opportunities in product line research is given. Section 4 summarizes key points of the presentations of the workshop participants that were given based on their submitted papers that are fully available at [2]. In Section 5, the plenary discussion is described and its major lessons learned are summarized. Section 6 concludes this paper.
Intractable ERP
Authors: Vogt Christian
Published: July 2004

An enterprise-resource-planning system --- or ERP system, for short --- is by definition "any software system designed to support and automate the business processes of medium and large businesses." [16] Integrated ERP systems became popular in the early 1990's. Single monolithic pieces of software, ERP systems promised to do away with inconsistent data, incompatible formats, and uncooperative applications.Still, ERP systems come with their own, unexpected difficulties. Their tremendous generality and enormous complexity make them prone to glitches and low performance, difficult to maintain, and nightmarish to implement.This study takes a close look at four ERP-implementation failures, all of which occurred recently in American industry. It analyses possible causes that led to the disasters, and suggests software-engineering processes that help avoiding such outcomes. The Model-Based Architecting and Software Engineering (MBASE) guidelines, developed by Professors Barry Boehm and Daniel Port at the Center for Software Engineering (CSE) at USC, provide a base for these elaborations.The original workout is actually far more extensive than the abridgement published here. It can be downloaded from the CSE web page. Alternatively, it may be ordered from the author directly through email.
Executing real-time structured analysis specifications
Authors: Blumofe R. , Hecht A.
Published: July 2004

This paper describes a prototype system, Teamwork/ES™, that executes a real-time structured analysis specification in an interactive, intuitive, and graphical manner. The approach has been to integrate the work as an extension of an accepted real-time analysis environment. This integrated, graphical system is different from previous textual or tool-kit systems, and offers a natural way of simulating system specifications. The system can also perform dynamic reachability tests and deadlock detection. Additionally, the execution is run orthogonally to the viewing and editing of analysis objects.
A practical approach to software quality assurance
Authors: Livson B. U.
Published: July 2004

This report describes a comprehensive and practical approach to software quality assurance (SQA). The emphasis is on SQA organization, management and task profile on corporate basis. The relationships between SQA and systems engineering, software developer, project office, subcontractors, customer, and independent verification, validation and testing IVV&T are discussed. The SQA role in software configuration management (SCM) is covered. Software engineering methods, standards and tools that contribute to software quality are described. SQA manpower qualifications and the assignments SQA is capable of fulfilling as a function of the quality and quantity of available manpower are analyzed. The paper is based on the author's experience as manager of the Israel Aircraft Industries Ltd Engineering Division SQA from 1978-1986. No project specific data is presented and the approach presented should be valid both for embedded computer systems and data processing quality assurance.
Evaluation of current software costing tools
Authors: Martin R.
Published: July 2004

Much effort has been expended over the last several years to construct various tools which predict the development schedules and costs of software projects. The organizations which contract out system development work are starting to request that the contractor use a specific costing tool during the bid.This paper reports the results and recommendations of a software costing tool evaluation project which was recently carried out at MacDonald Dettwiler. The primary project goal was to model a suite of the company's completed projects and determine if currently available commercial tools could predict effort and elapsed project time.
A hypothetical computer to simulate microprogramming and conventional machine language
Authors: Sayers Jerry E. , Martin David E.
Published: July 2004

Microprogramming is no generally available to programmers because it may involve modification of a machine's native language. A hypothetical computer can provide a simulator for microprogramming projects and add considerably to one's understanding of the subject of microprogramming and the concept of a multilevel machine. The classical text,
Structured Computer Organization
by Andrew S. Tanenbaum, contains a design for such a hypothetical computer. This paper presents an implementation of this machine with a user interface to permit development of microprograms as well as development of programs at the conventional machine language programming level. The user interface is similar to that of MS-DOS's DEBUG program. In addition to providing the basis for projects in Computer Architecture and Computer Organization classes, the simulator is being used as a simplified hypothetical machine in a Systems Programming class for the development of assembler, linker, and loader projects.