bluuebunny/crossref_metadata_2025 huggingface dataset:
Teaching data structures with multiple collection class libraries
Authors: Fekete Alan
Published: July 2004

In recent years, the teaching of data structures has been revolutionised by object-oriented languages, especially Java, in which the concept of each Abstract Data Type is made explicit as an Interface. The existing texts, though, each use a single set of classes: sometimes a standard library such as Sun's SDK, but in other cases these form a library unique to the text. In contrast, this paper advocates an approach which seeks to prepare students for the common situation for software developers, who are asked to regularly adjust to a library they are unfamiliar with. The teaching we describe openly acknowledges the existence of many libraries. A single concept such as Stack is expressed in subtly different ways in each library; these differences are made explicit for the student. We also show examples of assessment tasks that can accompany the teaching.
Small-college supercomputing
Authors: Adams Joel , Vos David
Published: July 2004

A Beowulf cluster is a MIMD multiprocessor built from commodity off-the-shelf personal computers connected via a dedicated network, running free open-source software. Such a cluster can provide a supercomputer's performance at a small fraction of one's cost. For small colleges and universities, the relatively low cost of a Beowulf cluster makes it an attractive alternative to a commercial supercomputer. This paper details our experience building a Beowulf cluster at a four-year comprehensive college.
Managing undergraduate CS research
Authors: McGuffee James W. , Dershem Herbert L. , Lankewicz Linda B. , Lewandowski Gary , Lopez Dian , Slotterbeck Oberta A.
Published: July 2004

The focus of this panel is the role of computer science faculty in the undergraduate research process. The panel participants will share their personal experiences to highlight different approaches in developing and encouraging undergraduate computer science research.
Parameterized object sensitivity for points-to and side-effect analyses for Java
Authors: Milanova Ana , Rountev Atanas , Ryder Barbara G.
Published: July 2004

The goal of
points-to analysis
for Java is to determine the set of objects pointed to by a reference variable or a reference objet field. Improving the precision of practical points-to analysis is important because points-to information has a wide variety of client applications in optimizing compilers and software engineering tools. In this paper we present
object sensitivity,
a new form of context sensitivity for flow-insensitive points-to analysis for Java. The key idea of our approach is to analyze a method separately for each of the objects on which this method is invoked. To ensure flexibility and practicality, we propose a parameterization framework that allows analysis designers to control the tradeoffs between cost and precision in the object-sensitive analysis.
Side-effect analysis
determines the memory locations that may be modified by the execution of a program statement. This information is needed for various compiler optimizations and software engineering tools. We present a new form of side-effect analysis for Java which is based on object-sensitive points-to analysis.We have implemented one instantiation of our parameterized object-sensitive points-to analysis. We compare this instantiation with a context-insensitive points-to analysis for Java which is based on Andersen's analysis for C [4]. On a set of 23 Java programs, our experiments show that the two analyses have comparable cost. In some cases the object-sensitive analysis is actually faster than the context-insensitive analysis. Our results also show that object sensitivity significantly improves the precision of side-effect analysis, call graph construction, and virtual call resolution. These experiments demonstrate that object-sensitive analyses can achieve significantly better precision than context-insensitive ones, while at the same time remaining efficient and practical.
Model checking Java programs using structural heuristics
Authors: Groce Alex , Visser Willem
Published: July 2004

We describe work in troducing heuristic search into the Java PathFinder model checker, which targets Java bytecode. Rather than focusing on heuristics aimed at a particular kind of error (such as deadlocks) we describe heuristics based on a modification of traditional branch coverage metrics and other
structure
measures, such as thread inter-dependency. We present experimental results showing the utility of these heuristics, and argue for the usefulness of
structural heuristics
as a class.
A conservative algorithm for computing the flow of permissions in Java programs
Authors: Naumovich Gleb
Published: July 2004

Open distributed systems are becoming increasingly popular. Such systems include components that may be obtained from a number of different sources. For example, Java allows run-time loading of software components residing on remote machines. One unfortunate side-effect of this openness is the possibility that "hostile" software components may compromise the security of both the program and the system on which it runs. Java offers a built-in security mechanism, using which programmers can give permissions to distributed components and check these permissions at run-time. This security model is flexible, but using it is not straightforward, which may lead to insufficiently tight permission checking and therefore breaches of security.In this paper, we propose a data flow algorithm for automated analysis of the flow of permissions in Java programs. Our algorithm produces, for a given instruction in the program, a set of permissions that are checked on all possible executions up to this instruction. This information can be used in program understanding tools or directly for checking properties that assert what permissions must always be checked before access to certain functionality is allowed. The worst-case complexity of our algorithm is low-order polynomial in the number of program statements and permission types, while comparable previous approaches have exponential costs.
Domain partitioning for open reactive systems
Authors: Stoller Scott D.
Published: July 2004

Testing or model-checking an open reactive system often requires generating a model of the environment. We describe a static analysis for Java that computes a partition of a system's inputs: inputs in the same equivalence class lead to identical behavior. The partition provides a basis for generation of code for a most general environment of the system, i.e., one that exercises all possible behaviors of the system. The partition also helps the generated environment avoid exercising the same behavior multipletimes. Many distributed systems with security requirements can be regarded as open reactive systems whose environment is an adversary-controlled network. We illustrate our approach by applying it to a fault-tolerant and intrusion-tolerant distributed voting system and model-checking the system together with the generated environment.
The distribution of faults in a large industrial software system
Authors: Ostrand Thomas J. , Weyuker Elaine J.
Published: July 2004

A case study is presented using thirteen releases of a large industrial inventory tracking system. Several types of questions are addressed in this study. The first involved examining how faults are distributed over the different files. This included making a distinction between the release during which they were discovered, the lifecycle stage at which they were first detected, and the severity of the fault. The second category of questions we considered involved studying how the size of modules affected their fault density. This included looking at questions like whether or not files with high fault densities at early stages of the lifecycle also had high fault densities during later stages. A third type of question we considered was whether files that contained large numbers of faults during early stages of development, also had large numbers of faults during later stages, and whether faultiness persisted from release to release. Finally, we examined whether newly written files were more fault-prone than ones that were written for earlier releases of the product. The ultimate goal of this study is to help identify characteristics of files that can be used as predictors of fault-proneness, thereby helping organizations determine how best to use their testing resources.
Gamma system
Authors: Orso Alessandro , Liang Donglin , Harrold Mary Jean , Lipton Richard
Published: July 2004

In this paper, we present the G
AMMA
system, which facilitates remote monitoring of deployed software using a new approach that exploits the opportunities presented by a software product being used by many users connected through a network. G
AMMA
splits monitoring tasks across different instances of the software, so that partial information can be collected from different users by means of light-weight instrumentation, and integrated to gather the overall monitoring information. This system enables software producers (1) to perform continuous, minimally intrusive analyses of their software's behavior, and (2) to use the information thus gathered to improve and evolve their software.
Investigating the use of analysis contracts to support fault isolation in object oriented code
Authors: Briand L. C. , Labiche Y. , Sun H.
Published: July 2004

A number of activities involved in testing software are known to be difficult and time consuming. Among them is the isolation of faults once failures have been detected. In this paper, we investigate how the instrumentation of contracts could address this issue. Contracts are known to be a useful technique to specify the precondition and postcondition of operations and class invariants, thus making the definition of object-oriented analysis or design elements more precise. Our aim in this paper is to reuse and instrument contracts to ease testing. A thorough case study is run where we define contracts, instrument them using a commercial tool, and assess the benefits and limitations of doing so to support the isolation of faults. We then draw practical conclusions regarding the applicability of the approach and its limitations.
PROPANE
Authors: Hiller Martin , Jhumka Arshad , Suri Neeraj
Published: July 2004

In order to produce reliable software, it is important to have knowledge on how faults and errors may affect the software. In particular, designing efficient error detection mechanisms requires not only knowledge on which types of errors to detect but also the effect these errors may have on the software as well as how they propagate through the software. This paper presents the Propagation Analysis Environment (PROPANE) which is a tool for profiling and conducting fault injection experiments on software running on desktop computers. PROPANE supports the injection of both software faults (by mutation of source code) and data errors (by manipulating variable and memory contents). PROPANE supports various error types out-of-the-box and has support for user-defined error types. For logging, probes are provided for charting the values of variables and memory areas as well as for registering events during execution of the system under test. PROPANE has a flexible design making it useful for development of a wide range of software systems, e.g., embedded software, generic software components, or user-level desktop applications. We show examples of results obtained using PROPANE and how these can guide software developers to where software error detection and recovery could increase the reliability of the software system.
Effectively prioritizing tests in development environment
Authors: Srivastava Amitabh , Thiagarajan Jay
Published: July 2004

Software testing helps ensure not only that the software under development has been implemented correctly, but also that further development does not break it. If developers introduce new defects into the software, these should be detected as early and inexpensively as possible in the development cycle. To help optimize which tests are run at what points in the design cycle, we have built
Echelon,
a test prioritization system, which prioritizes the application's given set of tests, based on what changes have been made to the program.Echelon builds on the previous work on test prioritization and proposes a practical binary code based approach that scales well to large systems. Echelon utilizes a binary matching system that can accurately compute the differences at a basic block granularity between two versions of the program in binary form. Echelon utilizes a fast, simple and intuitive heuristic that works well in practice to compute what tests will cover the affected basic blocks in the program. Echelon orders the given tests to maximally cover the affected program so that defects are likely to be found quickly and inexpensively. Although the primary focus in Echelon is on program changes, other criteria can be added in computing the priorities.Echelon is part of a test effectiveness infrastructure that runs under the Windows environment. It is currently being integrated into the Microsoft software development process. Echelon has been tested on large Microsoft product binaries. The results show that Echelon is effective in ordering tests based on changes between two program versions.
On testing and conformance relations for UML statechart diagrams behaviours
Authors: Latella Diego , Massink Mieke
Published: July 2004

In this paper we study the formal relationship between testing preorder/equivalences for a behavioural subset of UML Statechart Diagrams and a conformance relation for implementations with respect to specifications given using such diagrams. We study the impact of
stuttering
on the above mentioned relationship. In the context of UMLSDs,
stuttering
occurs when no transition of the UMLSD is enabled by the current event in the current (global) state of the underlying state-machine. We consider both the case in which the semantics underlying the testing relations
does not
model stuttering explicitly - we call it the
non-stuttering
semantics - and the case in which it
does it
- i.e. the
stuttering
semantics. We show that in the first case the conformance relation is stronger than the reverse of the MUST preorder and, consequently, stronger than the MAY preorder. Much more interesting results can be proven in the second case, possibly under proper conditions on the sets of events under consideration. In fact the conformance relation is shown to coincide with the MAY preorder, and thus be implied by the reverse MUST preorder. Finally, we show important substitutivity properties which hold in the case of stuttering semantics.
Experiences in automating the testing of SS7 signalling transfer points
Authors: Moors Tim , Veeraraghavan Malathi , Tao Zhifeng , Zheng Xuan , Badri Ramesh
Published: July 2004

Signalling System 7 (SS7) is widely used for telephone signalling. Service providers need to frequently test their Signalling Transfer Points (STPs), which switch SS7 messages, for both protocol conformance and interoperability. This paper describes a system that automatically analyzes the data collected during STP tests. It consists of files that describe how the STPs are expected to behave during the test, and Perl code that translates this Expected Behavior into a program that can search the data collected during the test for the expected events, and report on whether the system passed the test. The system readily processed over 30,000 events for each test run, and identified abnormal behavior that could interfere with interoperability and protocol conformance.
Refactoring design models for inductive verification
Authors: Cheng Yung-Pin
Published: July 2004

Systems composed of many identical processes can sometimes be verified inductively using a network invariant, but systems whose component processes vary in some systematic way are not amenable to direct application of that method. We describe how variations in behavior can be "factored out" into additional processes, thus enabling induction over the number of processes. The process is semi-automatic: The designer must choose from among a set of idiomatic transformations, but each transformation is applied and checked automatically.
Semi-proving
Authors: Chen T. Y. , Tse T. H. , Zhou Zhiquan
Published: July 2004

We present a semi-proving method for verifying necessary conditions for program correctness. Our approach is based on the integration of global symbolic evaluation and metamorphic testing. It is relatively easier than conventional program proving, and helps to alleviate the problem that software testing cannot show the absence of faults.
Continuity in software systems
Authors: Hamlet Dick
Published: July 2004

Most engineering artifacts behave in a continuous fashion, and this property is generally believed to underlie their dependability. In contrast, software systems do not have continuous behavior, which is taken to be an underlying cause of their undependability. The theory of software reliability has been questioned because technically the sampling on which it is based applies only to continuous functions.This paper examines the role of continuity in engineering, particularly in testing and certifying artifacts, then considers the analogous software situations and the ways in which software is intrinsically unlike other engineered objects. Several definitions of software 'continuity' are proposed and related to ideas in software testing. It is shown how 'continuity' can be established in practice, and the consequences for testing and analysis of knowing that a program is 'continuous.Underlying any use of software 'continuity' is the continuity of its specification in the usual mathematical sense. However, many software applications are intrinsically discontinuous and one reason why software is so valuable is its natural ability to handle these applications, where it makes no sense to seek software 'continuity' or to blame poor dependability on its absence.
ISSTA 2002 panel
Authors: Bertolino Antonia
Published: July 2004

ISSTA is at its twelfth edition. Also this year, researchers from academy and industry have contributed with many interesting studies and experience reports in software analysis and testing. We --- the ISSTA partakers- have (or at least believe to have) clear ideas about which are the problems to be solved, which are the real challenges, and probably each of us has already settled an agenda of the next steps to take for solving them looking ahead to the next ISSTA edition.Are we doing right? Do we know which are the real issues in the field? Is our research addressing relevant points, or just aesthetic questions? Do, and how much, industrial users ---the ISSTA addressees- value our papers and our achievements?This panel will address such questions by grouping a set of managers from different industries around a table and asking their opinions. As the above questions are very general, in the intent to tackle the theme in a concrete way, we will trigger the discussion by looking at the research results in terms of their potential impact in their respective enterprises. We would like to know which are currently the costs of testing and analysis activities in their industries, which are the items summing up such costs, and how we ISSTA researchers could help improving them.
Is ISSTA research relevant to industrial users? panel - ISSTA 2002
Authors: Encontre Vincent
Published: July 2004

In this paper - scoped for the panel discussion at ISSTA 2002 - we are discussing some techniques to ease the adoption of testing techniques by the developers, by extending the debugging activity. We also briefly discuss a longer term vision where the same paradigm applies but at model level, when coding will be achieved using visual notations such as UML.
Panel discussion
Authors: Sreenivas Ashok
Published: July 2004

We discuss the direct relevance of on-going testing research to the 'users' of the research, namely the industrial practitioners. The current state-of-the-practice in software testing is quite
ad-hoc
and provides little or no
assertions
about the quality of the delivered software product. We propose the view that research that is aligned with formal approaches to software development is the best bet to achieve this goal.
Automatic extraction of object-oriented component interfaces
Authors: Whaley John , Martin Michael C. , Lam Monica S.
Published: July 2004

Component-based software design is a popular and effective approach to designing large systems. While components typically have well-defined interfaces, sequencing information---which calls must come in which order---is often not formally specified.This paper proposes using multiple finite statemachine (FSM) submodels to model the interface of a class. A submodel includes a subset of methods that, for example, implement a Java interface, or access some particular field. Each state-modifying method is represented as a state in the FSM, and transitions of the FSMs represent allow able pairs of consecutive methods. In addition, state-preserving methods are constrained to execute only under certain states.We have designed and implemented a system that includes static analyses to deduce illegal call sequences in a program, dynamic instrumentation techniques to extract models from execution runs, and a dynamic model checker that ensures that the code conforms to the model. Extracted models can serve as documentation; they can serve as constraints to be enforced by a static checker; they can be studied directly by developers to determine if the program is exhibiting unexpected behavior; or they can be used to determine the completeness of a test suite.Our system has been run on several large code bases, including the joeq virtual machine, the basic Java libraries, and the Java 2 Enterprise Edition library code. Our experience suggests that this approach yields useful information.
Principles of survey research part 2
Authors: Kitchenham Barbara A. , Pfleeger Shari Lawrence
Published: July 2004

This second article of our series looks at the process of designing a survey. The design process begins with reviewing the objectives, examining the target population identified by the objectives, and deciding how best to obtain the information needed to address those objectives. However, we also need to consider factors such as determining the appropriate sample size and ensuring the largest possible response rate.To illustrate our ideas, we use the three surveys described in Part 1 of this series to suggest good and bad practice in software engineering survey research.
Computing program weakness using module coupling
Authors: Aggarwal K. K. , Singh Yogesh , Chhabra Jitender Kumar
Published: July 2004

In this paper, a method has been developed to measure the weakness of the program using module weakness and different types of module coupling. The paper justifies the need of considering coupling effect on program weakness. Various types of coupling are computed using parameters/variables and module weakness is found using average number of live variables and average life of variables in the module. The module coupling and module weakness values are used to compute program weakness, which can be used to indicate the maintainability and testability of the program.
Information systems accreditation
Authors: Gorgone John T.
Published: July 2004

This column briefly reviews the history of information systems (IS) accreditation and presents a set of criteria, that are in the development stages, for accrediting IS programs. The purpose of the draft IS criteria is to generate discussion within the professional community that will lead to support and improvements in the criteria and endorsement of the IS accreditation process.Educators expressed interest in IS accreditation soon after CSAB was formed in 1985. An IS accreditation workshop was held in November 1986 at the Fall Joint Computer Conference in Dallas. Representatives from ACM, IEEE-CS, and DPMA (now AITP) discussed the merits of and mechanisms for accreditation. There was sufficient interest to form a working group with one representative from each society to develop draft criteria.The group circulated the draft criteria and presented it to ACM's Accreditation Committee at the 1987 Computer Science Conference. Public presentations were made at the DPMA Educational Foundation's Information Systems Education Conference (ISECON) in 1987 and at the 19th ACM SIGCSE Technical Symposium in 1988. Each society published the criteria encourage discussion within the professional community. At the time, however, many IS programs were housed in an accredited AACSB school of business and these schools were not interested in program accreditation. DPMA was not interested in joining the ACM or the IEEE-CS in funding an IS accreditation process, so the idea was put on hold.Today, approximately 50% of IS programs are located outside schools of business and interest in accreditation is being revisited. NSF has provided a three-year grant to examine the feasibility of accreditation of programs in computer information science/systems/technology. The principal investigators (PI) of the study are project director Doris Lidtke of Towson University, and Co-PIs John T. Gorgone of Bentley College, John Henderson of Boston University, and Willis King of the University of Houston. The study includes the development of a set of criteria and procedures which may be used for accreditation of IS related programs. Check the IS accreditation web site [1] for ongoing information. This NSF-sponsored project brings together representation from all identified stakeholders:1. Leading information-computing societies: Association for Information Systems (AIS), Association for Computing Machinery (ACM), IEEE-Computer Society (IEEE/CS), and Association for Information Technology Processing (AITP);2. Major recent curriculum efforts, IS'97, ICC'99 and Curriculum '91;3. NSF funded curriculum development efforts;4 The Computing Sciences Accreditation Board; and representatives from industry and academic institutions.
An automatic testing and grading method for a C++ list class
Authors: Hitchner Lewis E.
Published: July 2004

This paper presents a scheme for automatic grading of the member functions of a C++ list class. Developing an automatic grading program for C++ classes is non-trivial because a test case to verify one member function of the class may depend upon the correctness of one or more other class member functions. In addition, performing multiple test cases in the same driver program may produce invalid grading outcomes because an erroneous result from one test case could violate the preconditions for a later test case. The method described here uses a weakness of C++ data encapsulation that allows access to private data members of an object. Two instances of a list object are constructed, tested, and compared using student designed and instructor designed classes. If a test case produces incorrect results using the student's class, the instructor written class may be used (via a type cast) to access the private data members of the student's list object to correct the errors. The grading program automatically reports and tallies errors for each member function and for the class total.
Code of ethics? which one?
Authors: Abi-Raad Maurice
Published: July 2004

We all have ideas about our local, national, and global professional code of ethics. But, we do not really know for sure how they interact. With the growth of global business practices, information technology (IT) professionals are wandering in a circle when it comes to ethical dilemmas. Which ethical standards should they follow? Should they adhere to their local IT professional standards; should they swear allegiance to their national IT vision, their country and its cultural and historical influences on professional IT practices? Or, should they give in to the global set of ethical behaviors dictated by their global employer when power, profit and politics impose new codes of ethics across the whole world. Furthermore, with the new structures of the global organizations, the global market has a pool of professionals and each one of them has his/her own interpretation of their own respective code of ethics. All these issues will certainly leave our young professional graduates in a state of divided loyalty. Whichever way our IT graduates choose, they are bound to have conflicts.The pursuit of good ethical practices is indeed a desirable aim. But, anyone waiting for a standard global solution is in a deep trouble, because there is none. This paper will propose a framework aimed at providing a contribution towards the socialization of students' self-regulated multicultural societies through international student exchange programs. The aim of the framework is to create a suitable environment where students can and will develop, assess, review and educate their own professional code of ethics for the current and future members of their students' mini-societies. This will eventually prepare them to be active participants in the bigger debate dealing with the issue of global professional code of ethics.
Analyzing information-flow in java program based on slicing technique
Authors: Li Bixin
Published: July 2004

Traditional information-flow analysis is mainly based on dataflow and control-flow analysis. In object-oriented program, because of pointer aliasing, inheritance, and polymorphism, information-flow analysis become very complicated. Especially, it is difficult to rely only on normal data and control-flow analysis techniques. some new approaches are required to analyze the information-flow between components in object-oriented program. In this paper, object-oriented program slicing technique is introduced. By this technique, the amount of information-flow, the width of information-flow and correlation coefficient between components can be computed. Some applications of the information-flow are also discussed and analyzed in this paper.
Teaching and learning in the 21st century
Authors: Lee John A. N.
Published: July 2004

Radical changes in teaching methods combined with the impact of the world wide web and the perceived need to make greater uses of the computer in education place the new faculty member at a considerable disadvantage. The TV generation of students find that it is no longer satisfying for a teacher to profess through stand-up lectures and expectations of self-initiated activities on the part of the learners. Additionally, a new topic needs to infiltrate the computer science curriculum, a topic that is not in the general repertoire of future faculty. This topic combines studies of ethical, social, and professional responsibilities with the other elements of the field. This paper proposes a curriculum for future faculty workshops to prepare new faculty to serve their departments.
The
UNLOCK
system
Authors: Beaubouef T. , Lucas R. , Howatt J.
Published: July 2004

Many colleges typically lose 50% of their CS1 students because they possess no fundamental problem solving skill. The development of an interactive learning tool,
UNLOCK,
teaches students those fundamental skills. This article describes
UNLOCK.
The goal is to increase CS1 retention, thereby increasing the numbers of CS graduates.
A web-based learning tool that simulates a simple computer architecture
Authors: Butler Jucain E. , Brockman Jay B.
Published: July 2004

As a supplement to an introduction to engineering systems course, the article presents a self-paced, web-based learning tool that introduces computer concepts by simulating the Lego Mindstorm s RCX programmable brick. It discusses the motivation for creating this tool and its implementation. The materials presented give students a broader perspective of an engineering system (the computer) and a sense of what goes on under the hood of a computer. They also give students, in conjunction with a physical laboratory project, a sense of working on a real workplace assignment.
Dimensions of distance learning for computer education
Authors: Clear Tony , Haataja Arto , Meyer Jeanine , Suhonen Jarkko , Varden Stuart A.
Published: July 2004

In this paper, we explore what is variously termed distance learning (DL), asynchronous, online, Web-based, and Web-supported learning in terms of how it can support and perhaps even improve the fields of education involving computing. We use the term distributed education to cover all mentioned topics. We describe how the incorporation of these methods can benefit computer education. These benefits arise because of the nature of the computing field, the profound requirements for students to understand concepts and acquire skills as opposed to mere exposure to facts, and our assessment that distributed education has the potential to address many of the challenges identified. We conclude with suggestions on the incorporation of distributed methods into computer education.
Notes on the academic job market and hiring strategies
Authors: Walker Henry
Published: July 2004

Today's tight job market challenges colleges and universities in hiring. This article reviews the current job market and suggests strategies for a successful hiring effort.
A method for normalizing students' scores when employing multiple graders
Authors: Jacobson Norman
Published: July 2004

Teachers of large classes often employ multiple graders to score student work. Even when appropriate measures are taken to insure that scoring by different graders is consistent, inconsistencies nevertheless occur. To adjust for them, instructors sometimes normalize grades mathematically, typically by scaling each grader group's score to an average of points earned. Scaling to an average has undesirable traits, including the difficulty of convincing students that it is fair. We developed an easy-to-explain method that adjusts scores so that the average number of points lost by students in each grader's group is the same. We discuss how to compute the adjustment and its advantages and limitations.
Network architecture
Authors: Chung Sei-Jong
Published: July 2004

In this paper, we examine how detect and correct transmission errors transmission control protocols such as TCP. We will first show how to construct Hamming Codes to detect and correct single-bit transmission errors. Then, we will evaluate various aspects of the Cyclic Redundancy Check (CRC) codes in comparison to Hamming Codes. The efficiency and the ease with which we can build and implement CRC codes are some of the aspects of the CRC codes that this paper explores.
Programming for students of information design
Authors: Ariga Taeko , Tsuiki Hideki
Published: July 2004

Programming is one of the subjects which students of information design need to study. Programming training will improve their multimedia representation, even when they use software packages. It will also enlarge the possibility of new interactive multimedia art over the internet. We propose course materials to teach programming by Java, which have been applied to a programming course in the Department of Information Design.
IFIP/UNESCO's informatics curriculum framework 2000 for higher education
Authors: Mulder Fred , van Weert Tom
Published: July 2004

Informatics is a relatively new discipline, nowadays of key importance in all economic processes. Many professionals are needed with different informatics backgrounds. The Informatics Curriculum Framework 2000 (ICF-2000) has been designed to cope with a large diversity in demands for informatics education in a controlled way. It offers 8 different curriculum specifications that fit 8 professional role categories. It supports systematic and controlled educational policies in which educational informatics programmes can be developed in a cost-effective way, if need be from scratch. Learning materials can be developed in the local cultural tradition. ICF-2000 has many source links to model informatics curricula from leading professional informatics societies. Through this mechanism ICF-2000 can be easily kept up to date.
A multi-national, multi-institutional study of assessment of programming skills of first-year CS students
Authors: McCracken Michael , Almstrum Vicki , Diaz Danny , Guzdial Mark , Hagan Dianne , Kolikant Yifat Ben-David , Laxer Cary , Thomas Lynda , Utting Ian , Wilusz Tadeusz
Published: July 2004

In computer science, an expected outcome of a student's education is programming skill. This working group investigated the programming competency students have as they complete their first one or two courses in computer science. In order to explore options for assessing students, the working group developed a trial assessment of whether students can program. The underlying goal of this work was to initiate dialog in the Computer Science community on how to develop these types of assessments. Several universities participated in our trial assessment and the disappointing results suggest that many students do not know how to program at the conclusion of their introductory courses. For a combined sample of 216 students from four universities, the average score was 22.89 out of 110 points on the general evaluation criteria developed for this study. From this trial assessment we developed a framework of expectations for first-year courses and suggestions for further work to develop more comprehensive assessments.
The kernel of Modula-2 integrated environment
Authors: Guoliang Z. , Chengxiang Z.
Published: July 2004

Integrated method is one of the effective methods to improve the efficiency of the software engineering environment. This paper describes the design of a Modula-2 integrated environment and its kernel environment which is implemented on IBM/PC-AT in Modula-2 language itself. The kernel environment supports incremental compiling and separate debugging of Modula-2 programs. It also supports the integration of the editor and the debugger. It is hoped that the whole Modula-2 integrated environment can be implemented based on the kernel environment and the environment information data base.
Problem reporting and development tracking using VM/SP
Authors: Murray J.
Published: July 2004

This paper discusses some aspects of handling software error information in an environment where development is also in progress. A tool called RPT is described, combining the twin tasks of problem reporting and enhancement tracking in a medium-sized operating system project. RPT runs under IBM VM/ISP and uses CMS and XEDIT.
Architectural primitives for distribution and mobility
Authors: Lopes Antónia , Fiadeiro José Luiz , Wermelinger Michel
Published: July 2004

In this paper, we address the integration of a distribution dimension in an architectural approach to system development and evolution based on the separation between coordination and computation. This third dimension allows us to separate key concerns raised by mobility, thus contributing to our ability to handle the complexity that is inherent to systems required to operate in "Internet time and space".
Improving program slicing with dynamic points-to data
Authors: Mock Markus , Atkinson Darren C. , Chambers Craig , Eggers Susan J.
Published: July 2004

Program slicing is a potentially useful analysis for aiding program understanding. However, slices of even small programs are often too large to be generally useful. Imprecise pointer analyses have been suggested as one cause of this problem. In this paper, we use dynamic points-to data, which represents optimal or optimistic pointer information, to obtain a bound on the best case slice size improvement that can be achieved with improved pointer precision. Our experiments show that slice size can be reduced significantly for programs that make frequent use of calls through function pointers because for them the dynamic pointer data results in a considerably smaller call graph, which leads to fewer data dependences. Programs without or with only few calls through function pointers, however, show only insignificant improvement. We identified Amdahl's law as the reason for this behavior: C programs appear to have a large fraction of direct data dependences so that reducing spurious dependences via pointers is only of limited benefit. Consequently, to make slicing useful in general for such programs, improvements beyond better pointer analyses will be necessary. On the other hand, since we show that collecting dynamic function pointer information can be performed with little overhead (average slowdown of 10% for our benchmarks), dynamic pointer information may be a practical approach to making slicing of programs with frequent function pointer use more successful in reality.
The logic of bugs
Authors: Holzmann Gerard J.
Published: July 2004

Real-life bugs are successful because of their unfailing ability to adapt. In particular this applies to their ability to adapt to strategies that are meant to eradicate them as a species. Software bugs have some of these same traits. We will discuss these traits, and consider what we can do about them.
Verifying cross-cutting features as open systems
Authors: Li Harry , Krishnamurthi Shriram , Fisler Kathi
Published: July 2004

Feature-oriented software designs capture many interesting notions of cross-cutting, and offer a powerful method for building product-line architectures. Each cross-cutting feature is an independent module that fundamentally yields an
open
system from a verification perspective. We describe desiderata for verifying such modules through model checking and find that existing work on the verification of open systems fails to address most of the concerns that arise from feature-oriented systems. We therefore provide a new methodology for verifying such systems. To validate this new methodology, we have implemented it and applied it to a suite of modules that exhibit feature interaction problems. Our model checker was able to automatically locate ten problems previously found through a laborious simulation-based effort.
Secure systems development based on the common criteria
Authors: Vetterling Monika , Wimmel Guido , Wisspeintner Alexander
Published: July 2004

Security is a very important issue in information processing, especially in open network environments like the Internet. The
Common Criteria
(CC) is the standard requirements catalogue for the evaluation of security critical systems. Using the CC, a large number of security requirements on the system itself and on the system development can be defined. However, the CC does not give methodological support.In this paper, we show how integrate security aspects into the software engineering process. The activities and documents from the Common Criteria are tightly intertwined with the system development, which improves the quality of the developed system and reduces the additional cost and effort due to high security requirements. For modelling and verification of critical parts of the system, we use formal description techniques and model checking (supported by the graphical CASE tool A
UTO
F
OCUS
), which increases both the understanding of the system specification and the system's reliability. We demonstrate our ideas by means of a case-study, the PalME project--an electronic purse application for Palm handhelds.
Recompilation for debugging support in a JIT-compiler
Authors: Tikir Mustafa M. , Hollingsworth Jeffrey K. , Lueh Guei-Yuan
Published: July 2004

A static Java compiler converts Java source code into a verifiably secure and compact architecture-neutral intermediate format, called Java
byte codes
. The Java byte codes can be either interpreted by a Java Virtual Machine or translated into native code by Java Just-In-Time compilers. Static Java compilers embed debug information in the Java class files to be used by the source level debuggers. However, the debug information is generated for architecture independent byte codes and most of the debug information is valid only when the byte codes are interpreted. Translating byte codes into native instructions puts a limitation on the amount of usable debug information that can be used by source level debuggers. In this paper, we present a new technique to generate valid debug information when Just-In-Time compilers are used. Our approach is based on the
dynamic recompilation
of Java methods by a fast code generator and lazily generates debug information when it is required. We also present three implementations for
field watch
support in the Java Virtual Machine Debugger Interface to investigate the runtime overhead and code size growth by our approach.
Selective path profiling
Authors: Apiwattanapong Taweesup , Harrold Mary Jean
Published: July 2004

Recording dynamic information for only a subset of program entities can reduce monitoring overhead and can facilitate efficient monitoring of deployed software. Program entities, such as statements, can be monitored using probes that track the execution of those entities. Monitoring more complicated entities, such as paths or definition-use associations, requires more sophisticated techniques that track not only the execution of the desired entities but also the execution of other entities with which they interact. This paper presents an approach for monitoring subsets of one such program entity---acyclic paths in procedures. Our
selective path profiling
algorithm computes values for probes that guarantee that the sum of the assigned value along each acyclic path (path sum) in the subset is unique; acyclic paths not in the subset may or may not have unique path sums. The paper also presents the results of studies that compare the number of probes required for subsets of various sizes with the number of probes required for profiling all paths, computed using Ball and Larus' path profiling algorithm. Our results indicate that the algorithm performs well on many procedures by requiring only a small percentage of probes for monitoring the subset.
Using the observer design pattern for implementation of data flow analyses
Authors: Naumovich Gleb
Published: July 2004

Data flow analysis is used widely in program compilation, understanding, design, and analysis tools. In data flow analysis, problem-specific information is associated with nodes and/or edges in the flow graph representation of a program or component and re-comp\-uted iteratively. A popular data flow analysis design relies on a worklist that stores all nodes and edges whose data flow information has to be re-computed. While this approach is straightforward, it has some drawbacks. First, the presence of the worklist makes data flow algorithms centralized, which may reduce effectiveness of parallel implementations of these algorithms. Second, the worklist approach is difficult to implement in a way that minimizes the amount of information passed between flow graph nodes.In this paper, we propose to use the well-known Observer pattern for implementation of data flow analyses. We argue that such implementations are more object-oriented in nature, as well as less centralized, than worklist-based ones. We argue that by adopting this Observer-based view, data flow analyses that minimize the amount of information passed between flow graph nodes can be implemented easier than by using the worklist view. We present experimental data indicating that for some types of data flow problems, even single-threaded implementations of Observer-based data flow analysis have better run times than comparable worklist-based implementations.