bluuebunny/crossref_metadata_2025 huggingface dataset:
Containment units
Authors: Cobleigh Jamieson M. , Osterweil Leon J. , Wise Alexander , Lerner Barbara Staudt
Published: July 2004

Software is increasingly expected to run in a variety of environments. The environments themselves are often dynamically changing when using mobile computers or embedded systems, for example. Network bandwidth, available power, or other physical conditions may change, necessitating the use of alternative algorithms within the software, and changing resource mixes to support the software. We present Containment Units as a software architecture useful for recognizing environmental changes and dynamically reconfiguring software and resource allocations to adapt to those changes. We present examples of Containment Units used within robotics along with the results of actual executions, and the application of static analysis to obtain assurances that those Containment Units can be expected to demonstrate the robustness for which they were designed.
Triggered message sequence charts
Authors: Sengupta Bikram , Cleaveland Rance
Published: July 2004

We propose an extension to Message Sequence Charts called
Triggered Message Sequence Charts
(TMSCs) that are intended to capture system specifications involving nondeterminism in the form of
conditional scenarios.
The visual syntax of TMSCs closely resembles that of MSCs; the semantics allows us to translate a TMSC specification into a framework that supports a notion of refinement based on Denicola's and Hennessy's must preorder. A simple but non-trivial example illustrates the utility of our extension to MSCs.
Monitoring deployed software using software tomography
Authors: Bowring Jim , Orso Alessandro , Harrold Mary Jean
Published: July 2004

Software products are often released with missing functionality or errors that result in failures in the field. In previous work, we presented the
Gamma
technology, which facilitates remote monitoring of deployed software and allows for a prompt reaction to failures. In this paper, we investigate one of the principal technologies on which
Gamma
is based: software tomography.
Software tomography
splits monitoring tasks across many instances of the software, so that partial information can be (1) collected from users by means of light-weight instrumentation and (2) merged to gather the overall monitoring information. After describing the technology, we illustrate an instance of software tomography for a specific monitoring task. We also present two case studies that we performed to evaluate the presented technique on a real program. The results of the studies show that software tomography can be successfully applied to collect accurate monitoring information using only minimal instrumentation on each deployed program instance.
The marking system for CourseMaster
Authors: Higgins Colin , Symeonidis Pavlos , Tsintsifas Athanasios
Published: July 2004

CourseMaster (CM) is a Computer Based Assessment (CBA) system. This paper describes the motivation and aims for developing CM's Marking System. It also explains the architectural forces and design decisions that have been established in order to engineer the Marking System. The Marking System adheres to the rigid specifications of the initial CM's design, which are: reliability, coherency, security, feedbackrichness, extensibility and customisability. The above notions and the features that CM's Marking System provides are examined in detail. Concrete implementation issues are also discussed with conclusions on usability and extensibility observations.
A testbed for pedagogical requirements in algorithm visualizations
Authors: Rößling Guido , Naps Thomas L.
Published: July 2004

Although algorithm visualizations have become numerous, they still have not been successfully adapted into mainstream computer science education. Algorithm visualization systems need to better address pedagogical requirements for effective educational use. We discuss the relevance of several such requirements that are not supported in most systems. The combination of two existing algorithm visualization systems implements these requirements and thereby provides a rich testbed for future studies of effectiveness.
A taxonomy of computer architecture visualizations
Authors: Yehezkel Cecile
Published: July 2004

In the domain of software visualizations, taxonomies have been built to classify and evaluate environments for algorithm and program visualization. Taxonomies are valuable too, in the development phase of new environment. The field of computer architecture and assembly language that is at the border of the software and hardware domains has been neglected. In this paper I present a taxonomy focusing on this field with emphasis on the didactic and cognitive aspect of the visualization environment. The ECPU learning environment was developed to teach computer architecture and assembly language at introductory level. The considerations that were taken in account during the ECPU development are presented in the context of the taxonomy.
International education in information technology
Authors: Voracek Jan , Kontro-Vesivalo Nina
Published: July 2004

We are developing a model of international education in Information Technology, the concrete realization of which is the International Master's Program in Information Technology (
IMPIT
) oriented for bachelor-level students from Russia and Czech Republic.The program has been running since 1998 and is realized commonly by three Eastern Finland universities: Lappeenranta University of Technology (LUT), University of Joensuu and University of Kuopio. The 2-years long advanced level studies of the program consist of a combination of courses in data processing and telecommunication.After one year of intensive theoretical studies the students are recruited to companies in Finland for full-time working and master thesis elaboration. In a larger scale the program aims at creating wide cooperation in the fields of education, research and business with Russia and especially with the St. Petersburg region.Relying on the experience gained from the so far three program cycles, in this poster we seek to give a general overview of the development and current status of our model which we have seen to grow into what might be called a working interchange between three European countries: Finland, Russia and Czech Republic. Based on our view that a lot of emphasis has to be put on the students' opinions and experience of the program, we present the results and conclusions drawn out of the feedback gathered from the students of all three cycles (1999-2000, 2000-2002 and 2001-2003) in the end of October 2001.Combining our earlier experience with the recently gathered data, we present the conclusions for further development of our model pointing out its strengths and weaknesses and bringing forth suggestions on development and applicability of our model in the future.
Admission control and resource reservation on the internet
Authors: Vogt Christian
Published: July 2004

Software engineers used to have a hard time developing real-time and interactive Web applications, Most of such software requires high and stable throughput, a prerequisite which the Internet's best-effort service does not provide. Hence, a large body of effort has recently gone, and is currently going, into modifications to the Internet architecture. Software engineers should closely monitor this research, and leverage new technologies to build applications that get the most from the Web.This study explains how the Internet Engineenng Task Force's (IETF) working groups IntServ and DiffServ seek to transition the Internet into a robust platform for high quality of service. It elaborates on the Resource Reservation Protocol's (RSVP) method of procedure to reserve bandwidth and buffer space in IP routers along a data flow's sender-receiver path. It presents the Subnet Bandwidth Manager's (SBM) mapping of RSVP functionality onto local- and metropolitan-area networks that use a shared medium. Furthermore, it discovers a way to implement demanding, yet adaptive, Web applications that are content with traditional best effort. The paper concludes with the Common Open Policy Service (COPS), a framework for policy decision-making and enforcement.
Issues of dependability in open source software development
Authors: Lawrie Tony , Gacek Cristina
Published: July 2004

This paper presents issues raised by the articles, presentations, and discussions concerning Open Source Software, Trustworthiness, and Dependability at the Open Source Development Workshop held in Newcastle upon Tyne, UK, on the 25
th
& 26
th
of February 2002.
Component-based software engineering
Authors: Crnkovic Ivica , Larsson Stig , Stafford Judith
Published: July 2004

This paper gives a short overview of the Workshop on Component-based Software Engineering - Building Systems from Components held at 9th IEEE Conference and Workshops on Engineering of Computer-Based Systems in Lund, Sweden, April, 2002. The aim of the workshop was to bring together researches and practitioners from system engineering, software architecture and from component-based software engineering communities in order to exchange experiences and research results from these domains.
Declarative Meta Programming to Support Software Development
Authors: Mens Tom , Wuyts Roel , De Volder Kris , Mens Kim
Published: July 2004

This paper reports on the results of the workshop on Declarative Meta Programming to Support Software Development in Edinburgh on September 23, 2002. It enumerates the presentations made, classifies the contributions and lists the main results of the discussions held at the workshop. As such it provides the context for future workshops around this topic.
Graphical notations for active rules in UML and UML-A
Authors: Berndtsson Mikael , Calestam Bengt
Published: July 2004

Active rules (i.e., event condition action rules, triggers) have been put forward as a technique for reacting to important events, and thereby avoiding polling or embedding rule processing in applications. Despite the promises of active rules technology, the usage of active rules is low in practice. It has often been claimed (by database researchers) that the reason why few active rules applications have been built is due to the lack of support in analysis and design phases. Hence, there are very few notations or guidelines available for software engineers who develop active rules applications.In this paper, we propose modelling templates for UML state-charts and UML-A statecharts for how software engineers can capture the fundamentals of active rules. By following the proposed modelling templates and notations for active rules, it will be easier for software engineers to develop applications that rely on active rules technology.
Is KS=(D+I+S+K)*E + KM?
Authors: Llorens Juan , Prieto-Díaz Rubén
Published: July 2004

Is it time for a science of knowledge? In this paper we argue that yes, it is time and define it as:KS = (D+I+S+K)*E + KMWhere KS is Knowledge Science, DE is Domain Engineering, IE is Information Engineering, SE is Software Engineering and KE is Knowledge Engineering, and that Knowledge Management (KM) moderates these disciplines. We try to clarify the apparent state of confusion in the current landscape where KS, KM and KE have different meanings to different audiences. After clarifying the difference between KE and KM and arguing that KE and KM are complementary we explain why we selected the word knowledge instead of information and decided on the word science in KS. The core of the paper explains the term (D+I+S+K)*E in our proposed definition and why each of these disciplines contribute to KS. One of our conclusions is that KS deals with knowledge about knowledge, or about the knowledge needed to increase, expand or further acquire more knowledge, and that KS can be applied to all the existing sciences, covering their needs of methodologies, techniques and tools.
Using object-oriented methods in a system lifecycle process model
Authors: Sahraoui A. E. K. , Blum T.
Published: July 2004

The paper proposes a technique of mapping an object oriented method (OMT) onto a software lifecycle process model (Development Standard for the German Federal Armed Forces Process (V-Model)). This technique is extended by the integration another established technique on the use of object oriented paradigm in system engineering. The combination of both techniques can be a preliminary step in bridging the gap between a software lifecycle development processes in software engineering and system engineering. Difficulties are discussed and perspectives for such work are presented.
A general framework for constructing application cooperating system in Windows environment
Authors: Xu Baomin , Lian Weimin , Gao Qiang
Published: July 2004

We often need to discuss or modify the results generated by single-user CAD applications when they are applied to cooperative design. To our knowledge, however, almost all the existing cooperative systems or tools, such as shared white-board and application sharing, have some limitations when used for to such task. When considering these limitations, we have coined the term "Application Cooperating" which means to retain the original features of the single-user CAD applications and when using them collaboratively. To reduce redundant development, we have developed a framework that converts a single-user CAD application into a multi-user application. To achieve this we have developed a framework whereby the events occurring through interactions with the application, can be captured, distributed, and reassembled, in such a way as to allow single-user CAD applications to be used cooperatively without modifications to their source codes. This paper main discusses the architecture, events process and other relative problems pertaining to the above.
New approach to software architecture
Authors: Zayaraz G. , Thambidurai P. , Kuppuswami S. , Rodrigues Paul
Published: July 2004

Software architecture aims at providing a high-level structure (blueprint) to be used by both the developer as well as the stakeholders. The blueprint consists of components and connectors. Certain combinations of these components and connectors yield the best design results. Vastushastra, an Indian building science, consists of patterns. It lays a set of building architectural rules that, when followed, offers quality of life. As a first attempt of our research, we propose applying the well-structured and proven results of Vastushastra to one of component of Software Architecture, Quality Trade-off.
Testing reusable software components from object specification
Authors: Ramachandran Muthu
Published: July 2004

Most Consumer Electronics products today contain complex embedded software. We believe a component-oriented approach is an ideal way to handle the diversity of software complexity. Our earlier work on reusable components addressing the development of the Koala component model has been shown (as an outcome of the ESPRIT project ARES) to address reuse with concept of late binding [1]. This work has been carried out as a part of the research project on 'Testing Reusable Software Components'. Our approach to testing components is based on the principles of testing from object models by decomposing a COM-like component into OO models. Therefore we are able to generate a volume of key test cases to study boundary value testing and analysis on component interfaces, which is the key to achieve testability and reusability of software components.
Foundations for the Arcadia environment architecture
Authors: Taylor Richard N. , Belz Frank C. , Clarke Lori A. , Osterweil Leon , Selby Richard W. , Wileden Jack C. , Wolf Alexander L. , Young Michal
Published: July 2004

Early software environments have supported a narrow range of activities (
programming
environments) or else been restricted to a single “hard-wired” software development process. The Arcadia research project is investigating the construction of software environments that are tightly integrated, yet flexible and extensible enough to support experimentation with alternative software processes and tools. This has led us to view an environment as being composed of two distinct, cooperating parts. One is the
variant
part, consisting of process programs and the tools and objects used and defined by those programs. The other is the fixed part, or
infrastructure
, supporting creation, execution, and change to the constituents of the variant part. The major components of the infrastructure are a process programming language and interpreter, object management system, and user interface management system. Process programming facilitates precise definition and automated support of software development and maintenance activities. The object management system provides typing, relationships, persistence, distribution and concurrency control capabilities. The user interface management system mediates communication between human users and executing processes, providing pleasant and uniform access to all facilities of the environment. Research in each of these areas and the interaction among them is described.
Graph attribution as a specification paradigm
Authors: Alpern Bowen , Carle Alan , Rosen Barry , Sweeney Peter , Zadeck Kenneth
Published: July 2004

An interactive software development environment can be viewed as a structure-based editor, provided that
structure
is broadly interpreted. The user sees and manipulates complex objects at various levels of detail. Many of the implications of changes are analyzed and made available to the user as frequently as the user wishes, without a mode change from editing to compiling or linking. To help provide these services in a uniform way that can readily respond to changes in the programming language(s) supported or in the preferences of individual users, some programming environments use attribute grammars.

The
attributed graph specifications (AGS's)
defined here are inspired by attribute grammars but are free of their restriction to structures expressible by parse trees generated by context-free grammars. An AGS deals with whatever structure is appropriate in a given application. The graph concept here is not tied to any decision about pictorial representation. Indeed, we do not care whether the user sees pictures or text or a combination of the two. The AGS formalism is a uniform paradigm for specifying the desired relations among many and varied chunks of information, some of which are changed by the user. The benefits of the original attribute grammar formalism were confined to parse trees and severely restricted manipulations of parse trees. The AGS paradigm extends those benefits to software development on a larger scale.
An undergraduate concentration in networking and distributed systems
Authors: Reek Margaret M.
Published: July 2004

This paper describes our experiences at Rochester Institute of Technology in establishing an undergraduate computer science concentration in networking and distributed systems. The concentration course sequence, prerequisite requirements, individual course structure, lab environment and student projects are discussed.
Modifying freshman perception of the CIS graduate's workstyle
Authors: Mawhinney Charles H. , Callaghan David R. , Cale Edward G.
Published: July 2004

Student interest in computer-related careers has declined dramatically in recent years. One possible explanation for this decline is incorrect perceptions of the workstyle associated with the positions held by CIS graduates. A study of freshman business majors was conducted which: (1) examined whether an introductory computing course changed those perceptions, and (2) compared those perceptions to their own expected starting positions. The study showed that: (1) the introductory computing course had a negligible effect on changing student perceptions of the nature of the CIS graduate's initial job, and (2) compared to their perceptions of CIS jobs, they expected their own jobs to involve substantially more human interaction and less direct involvement in the implementation of computer technology. The results suggest a need for: (1) a more proactive strategy to market the MIS career both inside and outside the classroom, and (2) some creative approaches for the placement and content of programming activities in both the major and the career.
The new generation of computer literacy
Authors: Myers J. Paul
Published: July 2004

A tremendous mismatch is developing between two of the most critical components of any computer literacy course: the textbooks and the students. We are encountering a “new generation” of students (literally as well as figuratively!) who are much better acquainted with computer usage than their earlier counterparts. Yet many textbooks with increasing emphasis in those same computer tools continue to appear. There are signs of a coming change in that a few authors and publishers apparently are becoming aware of the need for innovations in texts for non-scientists. These textbooks open the door for a new orientation to principles in the teaching of computer literacy.
An example illustrating modularity, abstraction & information hiding using
Authors: Liss Ivan B. , McMillan Thomas C.
Published: July 2004

In this paper we present, by way of an example, techniques for using the independently compilable units of Turbo Pascal 4.0. (Turbo Pascal is a Pascal compiler available from Borland International.) We suggest ways that units can be used to illustrate software engineering principles, including information hiding, modularity, and procedural and data abstraction. The paper describes Turbo Pascal units and gives a sample project. It also suggests a number of ways that this or similar projects can be used to illustrate these principles to CS1 and CS2 classes.
Visual metaphors for teaching programming concepts
Authors: Waguespack Leslie J.
Published: July 2004

This paper presents a system of visual metaphors used in a introductory programming course using Pascal. The visual metaphors represent programming concepts (data types, variables, arrays, records, files, modules, module interfaces and parameter passing, and dynamic storage) that are often difficult for beginning students to learn. The metaphors are used to accelerate the students' learning process and improve the overall comprehension of programs as structured objects. The system of metaphors is used in the first course for majors, Foundations of Programming, in the Computer Information Systems curriculum at Bentley College.
Operations on sets of intervals - an exercise for data structures or algorithms
Authors: Weems B. P.
Published: July 2004

Ordered linked lists are introduced in data structures courses and are frequently encountered in the study of algorithms. Set operations (e.g. union, intersection) on sets of real intervals provide a non-trivial exercise in developing correct algorithms for manipulating lists.
Xinu/WU: an improved PC-Xinu clone?
Authors: Hummel J.
Published: July 2004

In teaching an undergraduate course in Operating Systems, it is instructive if the students have an actual operating system they can study and modify. Care should be taken, however, in selecting a system that the students can realistically be expected to understand. Xinu/WU retains the advantages of its parent PC-Xinu [Fossum 1987]; a small yet relatively complete operating system for the IBM PC, supplied with full source code and able to run within its development environment. Xinu/WU incorporates three particular enhancements: an improved implementation, integration into Borland International's Turbo C™ run-time environment, and more effective use of the windowing system. The conclusion is that Xinu/WU increases the possibility of using such a system in an undergraduate Operating Systems course. Two ways in which it can be utilized are presented.
Teaching introductory and advanced computer graphics using micro-computers
Authors: Owen G. S.
Published: July 2004

In the past few years there have been significant advances in both the computational and graphics capabilities of micro-computers. In graphics the standard (for the IBM compatible world) has advanced from the Computer Graphics Adapter (CGA) through the Enhanced Graphics Adapter (EGA) to the present Video Graphics Array (VGA). With the multiple color capability of the VGA, images can be constructed which use graphics shading algorithms. This allows us to teach more advanced concepts in introductory courses and even to teach some topics in advanced courses using these machines. In this paper I will discuss how these hardware improvements have allowed for changes in our introductory graphics course and also our experience in teaching an advanced course using these machines.
Changes and extensions in the C family of languages
Authors: Lessman Roger E.
Published: July 2004

Some very important current developments are taking place within the C family of programming languages. Via the ANSI C Standard, extensions to C provide for stricter type-checking, better control of portability, and improved efficiency at run-time. The C++ language has further enhanced C to support data abstraction and inheritance. This paper briefly summarizes some of the C extensions which result from the ANSI C Standard and which will become important to courses which utilize C as a programming vehicle and as the subject for the study of the block-structured programming paradigm.
Demonstrating the dangers of Pseudo-random numbers
Authors: Danilowicz Ronald L.
Published: July 2004

Computer simulations are everywhere, from the corporate office to the local video game parlor. With the increased role being played by these simulations, it is important for students to be completely aware of the limitations of pseudorandom number generators. The fact that random number generators in use today are not truly random is no secret (The New York Times, C1-C8). Since most simulations produce reasonable results it might be difficult to convince students that there are any problems involved in trusting these random number generators. A simple simulation which can be used as a programming exercise in any language can dramatically reveal these dangers.The exercise used requires a statistical evaluation of π which yields horrible results. The results are not difficult to explain and the exercise can be extended by allowing students to experiment with modifications to the pseudo-random number generator used in attempts to "fix" the problem. This can be useful, as the attempts to fix the pseudorandom number generator usually aggravate rather than alleviate the problem.
Combining version control with automatic program building
Authors: Gordon M.
Published: July 2004

In the Unix
1
system, the problem of rebuilding a program of file when one or more source files change is solved separately (by
make
from the problem of maintaining past versions of the program source files (solved by SCCS or RCS). This paper describes a practical system that combines these functions and shows that by doing so, additional common software development problems can also be solved. These include tracking and recovering a complete set of the source files necessary to build an arbitrary release of a product, support for multiple developers working on products that share source code, and identifying the source file versions that went into any given software build. This system is called the Portable Configuration Management System. Other improvements upon past methods include compression of the source revisions, the ability to handle non-ASCII source files, and the ability to identify revisions of files by timestamp or 32-bit CRC in lieu of to the version number.
Augmented state-transition diagrams for reactive software
Authors: Hendricksen C. S.
Published: July 2004

The state transition diagram (STD) was invented in the '50's at Bell Laboratories to solve process control problems related to switching of telephone calls. This graphic technique, while extraordinarily descriptive and mathematically rigorous, was very expensive to maintain manually. The technique fell into disuse when tabular techniques were developed and taught to the new generation of electrical engineers. When modern interactive graphics are applied to the technique, and when the basic model is augmented with a simple graphic notation which allows both event processing and logical branching on system conditions, the augmented state transition diagram becomes a powerful CASE tool which is useful across most of the software life cycle.
Properties of Z specifications
Authors: Woodcock J. C. P.
Published: July 2004

In this paper we show how to calculate properties of specifications written in the Z notation. In particular, we show how the precondition of an operation may be derived using rewrite rules and an application-oriented theory. As an example, we take part of the specification of an industrial-sized problem. If proofs are conducted at the level of the
schema
, then the structure of the proof follows the structure of the specification, and the technique scales up for verification in the large.
Radical and conservative top-down development
Authors: Hill G.
Published: July 2004

This paper describes the conservative and radical approaches to top-down software development and makes a comparison of the two methods. This comparison discusses the advantages and disadvantages of each method and shows how they differ in affecting the development costs, efficiency, reliability, and maintainability of the resulting software. This paper also describes a hybrid approach to software development, which has successfully been used to obtain many of the benefits from both the conservative and radical methods of top-down software development.
Testing large software products
Authors: House D. E. , Newman W. F.
Published: July 2004

Software testing becomes more and more difficult the larger the software system gets. Operating systems and very large programming products often have special testing considerations that most application programs do not have. This paper describes a testing methodology with focus on system testing operating systems as implemented in an area of IBM's large systems software development - Myers Corners Laboratory, Poughkeepsie, New York. It also gives an overview of large-scale software manufacturing.
Synchronization problems and UNIX System V
Authors: Dunstan N.
Published: July 2004

The synchronization of concurrent processes is of great importance in multiprocessing operating systems and a general discussion, together with an exposition of classic synchronization problems, has traditionally appeared in operating systems texts. UNIX System V has a variety of mechanisms for for process synchronization which embody both shared memory and message passing techniques. This paper outlines those mechanisms and presents a set of classic synchronization problems with coded solutions in C for the UNIX System V environment. It also describes how they may be used to illustrate different synchronization techniques in the context of teaching about operating systems.
Teaching load and the quality of education
Authors: Sanders S. L.
Published: July 2004

This paper presents a summary of a daily log detailing my work as a Computer Science teacher with a load of 106 students in 4 different meeting sections and 3 different courses. This data, together with my experience of twelve years on the Computer Science faculty at SUNY-Geneseo suggest that teaching is no easy life. Indeed, it is necessary to work nights, weekends, and holidays to do an adequate job. Under such teaching loads, there is no time for family without taking time away from preparation, grading, and individual student teaching. The same is true of committee work, research, publishing, and other important professional activity. It is suggested that such heavy teaching loads reduce the quality and quantity of educational services to students; a situation that is exacerbated when extra-classroom duties are required.
Teaching programming to conversion course students
Authors: Briggs J. S.
Published: July 2004

This paper describes the author's experiences of teaching introductory programming and elements of software engineering to a group of students on a one year conversion course. It addresses how topics such as program design, programming in the large and program readability are taught. None of the students on the course have computing or engineering backgrounds.
Teaching of assembly language as a laboratory science
Authors: Weiner D. J.
Published: July 2004

This paper describes our experience with the implementation of laboratories associated with our undergraduate computer science courses. The beginning assembly language course was chosen as our first experiment with this concept for several reasons. Acquisition of new equipment necessitated reorganization of the course in any case, and the philosophy of learning by experimentation was most easily implemented in a subject "close to the hardware".The concept of a supervised lab in computer science, based on those used in the physical and natural sciences, is relatively new. Teaching assembly language in an assigned, supervised laboratory setting has overwhelming advantages over the more traditional lecture and open lab method. In addition to the obvious guaranteed computer time, the immediate availability of help allows much more material to be covered. Student and faculty acceptance of the labs has been uniformly enthusiastic. So much so, that all of our programming-intensive courses are now scheduled with labs. This paper presents descriptions of the original lab facility itself, later improvements to the facility, the course organization, and examination procedures. It concludes with some general observations and suggestions based on our experience.
The software engineering process: definition and scope
Authors: Humphrey W. S.
Published: July 2004

With the growing interest in the software engineering process, it is increasingly important to define what we mean by these words. This, however, also requires definitions for software and software engineering as well as some agreement on the scope and boundaries of these activities.
PMothra: scheduling mutants for execution on a hypercube
Authors: Choi B. , Mathur A. , Pattison B.
Published: July 2004

Reliable software testing is a time consuming operation. In addition to the time spent by the tester in identifying, locating, and correcting bugs, a significant time is spent in the execution of the program under test and its
instrumented
or
fault induced
variants. When using mutation based testing to achieve high reliability, the number of such variants can be very large. In this paper we describe the architecture of a tool named P
M
othra that is designed to provide an architecture-transparent interface to a tester. In its current version, P
M
othra exploits the hypercube architecture by scheduling the execution of mutants on a 128-node Ncube/7 hypercube.
Automating software analysis and testing using a program transformation system
Authors: Kotik G. , Markosian L.
Published: July 2004

We describe an approach to software analysis and test generation that combines several technologies: object-oriented databases and parsers for capturing and representing software; pattern languages for writing program templates and querying and analyzing a database of software; and transformation rules for automatically generating test cases based on the analysis results, and for automatically creating program “mutants” to determine adequacy of coverage of the test cases. We present a program transformation system, REFINE™
1
, that incorporates these technologies in an open environment for software analysis and test generation. Next we present concrete examples of how our approach is being applied to analysis and test generation for C software.
Approaches to specification-based testing
Authors: Richardson D. , O'Malley O. , Tittle C.
Published: July 2004

Current software testing practices focus, almost exclusively, on the implementation, despite widely acknowledged benefits of testing based on software specifications. We propose approaches to specification-based testing by extending a wide variety of implementation-based testing techniques to be applicable to formal specification languages. We demonstrate these approaches for the Anna and Larch specification languages.
The coupling effect: fact or fiction
Authors: Offutt A.
Published: July 2004

Fault-based testing strategies test software by focusing on specific, common types of errors. The
coupling effect
states that test data sets that detect simple types of faults are sensitive enough to detect more complex types of faults. This paper describes empirical investigations into the coupling effect over a specific domain of software faults. All the results from this investigation support the validity of the coupling effect. The major conclusion from this investigation is that by explicitly testing for simple faults, we are also implicitly testing for more complicated faults. This gives us confidence that fault-based testing is an effective means of testing software.
Experimental comparison of three system test strategies preliminary report
Authors: Rowland J. , Zuyuan Y.
Published: July 2004

This paper reports on some experiments which compare three system test strategies which were applied to artificial software systems. The artificial systems were seeded with known defects and then tested according to the three strategies which involved random system level input, random system level input with defect removal, and modified module coverage. The results suggests that of the three strategies considered here, the modified module coverage exposes a higher number of defects, especially for large systems.
Software engineering in the liberal arts
Authors: Dooley John F.
Published: July 2004

This paper describes the organization of a junior/senior level software engineering class offered at Knox College, a small, selective liberal arts college. It presents the reasoning for the design of the course and gives some results from the course. The course is somewhat novel in that it uses non-standard texts, depends heavily on journal articles for a theory component, and requires a large amount of writing and individual and team oral presentations.
E-notes
Authors: Wirth Michael A.
Published: July 2004

Writing comprehensive, focused notes during a lecture can be a challenging task for students. They often spend most of the time actually writing notes with little time to reflect on the material presented in the lecture, or indeed to ask questions. Electronic lecture notes are a clear and concise electronic form of lecture notes provided openly to students. I use e-notes to complement the material presented in my lectures and experience has shown that they offer a distinct learning advantage over traditional forms of note taking. As students do not have to spend time writing copious notes, they are generally more attentive during class, being able to concentrate on understanding the material. This allows them to become actively engaged in the lecture, participating in class discussions and asking pertinent questions.
Developing intelligent programming tutors for novice programmers
Authors: Pillay Nelishia
Published: July 2004

First year Computer Science students often encounter difficulties when learning to write procedural and object-oriented programs for the first time. This is also true of students being exposed to a new programming paradigm. One-on-one tutoring has proven to be the most effective means of assisting first time programmers overcome learning difficulties. However, due to large class numbers and funding constraints the provision of one-on-one tutoring is not usually possible. Intelligent tutoring systems (ITSs) have successfully been used to tutor novice programmers on a one-on-one basis. Despite this, intelligent programming tutors (IPTs) are not widely used and few such systems have made their way into the classroom. This can be attributed to the high developmental costs associated with building IPTs. The paper firstly identifies the facilities that must be provided by intelligent programming tutors. In an attempt to reduce the costs of developing IPTs, the paper proposes a generic architecture for the development of intelligent programming tutors. The paper specifies the components that should comprise such an architecture and describes the functions that must be performed by each component.
Faculty and the 21
st
century student in USA higher education
Authors: Salcedo Michaelangelo
Published: July 2004

The present student body in higher educations is very diverse and of a wide range of preparedness. Faculties are challenged to reflect on their teaching and the concerns and need of their students. Student assessments reveal critical thinking skills, problem solving skills and motivation and help faculty develop better instructional designs. Introductory courses in programming are of great consternation to faculty and student alike. Ideas to revise present introductory course in programming is presented.
A computational science case study
Authors: Phillips Andrew T. , Buerkle C. Alex
Published: July 2004

A self-contained undergraduate level "case study" in computational science/biology is described. The application presented brings together genetics, statistics, and numerical methods into a unified course project. The project we describe involves a statistical model and genetic classification of individuals that may be the result of hybridization between genetically divergent parents. Actual data consist of inherited genetic markers, which allow the evaluation of alternative model parameters by a maximum-likelihood technique. In the implementation of the classification model, the project provides opportunities for the use of numeric computing in C/C++ using libraries like the GNU Scientific Library for the computation of the model parameters.
The reverse trace
Authors: Lorenzen Torben
Published: July 2004

It is often difficult for a student to make the transition from tracing programs that others have written to writing her own first real program. The author suggests that the student create a trace first and then derive a program that would make that trace. This method is fittingly called a reverse trace.
Spreadsheet-aided numerical experimentation
Authors: Rolfe Timothy J.
Published: July 2004

Spreadsheet representations of recurrences allow numerical experimentation with potential analytic solutions to those recurrences. This paper uses a very simple recurrence for which the analytic solution is quite obvious when one examines the values generated by the recurrence, and then examines another recurrence for which the solution is not obvious.
A road map for teaching introductory programming using LEGO© mindstorms robots
Authors: Lawhead Pamela B. , Duncan Michaele E. , Bland Constance G. , Goldweber Michael , Schep Madeleine , Barnes David J. , Hollingsworth Ralph G.
Published: July 2004

In this paper, we describe a recent trend in the introductory computer science curriculum which advocates conceptualizing computation primarily as coordinated concurrent activities [8], [9], [10]. Consistent with this philosophy is the focus on the event-driven model of computation [7]. While one can utilize these approaches with any thread and/or event supporting object-oriented language (e.g. Java) in a desktop programming environment, they become particularly worthwhile when used in conjunction with physical robots. This paper argues the case for the benefits of this approach and provides sample exercises that illustrate the use of this pedagogy using Lego Mindstorms RCX bricks programmed in Java for use in introductory programming.
Taking advantage of national science foundation funding opportunities
Authors: Prey Jane , McDuffie Ernest , Taylor Harriet
Published: July 2004

This session will highlight NSF EHR Division of Undergraduate Education and CISE Division of Experimental and Integrative Activities programs of interest to college faculty, discussing the requirements and guidelines. It will include a discussion of the characteristics of a competitive proposal and the proposal process.
Academic dishonesty in a high-tech environment
Authors: Popyack Jeffrey L. , Herrmann Nira , Zoski Paul , Char Bruce , Cera Chris , Lass Robert N.
Published: July 2004

Advances in computing and telecommunication technology provide abundant new opportunities for academic dishonesty. Anecdotal evidence suggests that students are far more aware than faculty of various mechanisms for cheating on exams, plagiarizing assignments, and soliciting work for pay. Fortunately, technological advances also provide the alert instructor with some tools for combating such academic dishonesty.In this session, we will present information on how calculators, cell phones, beepers, and other handheld technology may be used to cheat on exams; how the Internet is used to match students with sources for solutions to their assignments; and existing tools and services for the faculty member.The intention of this session is to inform faculty about various ways that students may commit academic fraud; and tools and approaches that are available to reduce their effectiveness. We also hope to gain further information from other faculty and/or students in attendance. We do not intend to debate whether these activities should be allowed due to the ease with which they are committed, as is often discussed.We will provide a bibliography of articles about high-tech academic dishonesty, software tools and services for detecting plagiarism (including shared code in programming assignments), and Internet resources.
Computer science accreditation
Authors: Crouch Donald B. , Schwartzman Leslie
Published: July 2004

Outcome-based learning, as embraced by the CAC criteria for accrediting computing programs, requires by its very nature the active, on-going participation of faculty in the assessment process. This paper will describe a means of involving faculty at the earliest stages of development in a comprehensive assessment plan without making undue demands of their time or fostering the anxiety that oftentimes accompanies implementation of the assessment process. The proposed process takes advantage of the flexibility of the CAC criteria.
Computer-related gender differences
Authors: Rowell Ginger Holmes , Perhac Diane G. , Hankins Judith A. , Parker Brenda C. , Pettey Chrisila C. , Iriarte-Gross Judith M.
Published: July 2004

Computer-related gender differences are examined using survey responses from 651 college students. Issues studied include gender differences regarding interest and enjoyment of both using a computer and computer programming. Interesting gender differences with implications for teaching are examined for the groups (family, teachers, friends, others) that have the most influence on students' interest in computers. Traditional areas such as confidence, career understanding and social bias are also discussed. Preliminary results for a small sample of technology majors indicate that computer majors have unique interests and attitudes compared to other science majors.
MiniMIPS
Authors: Bem Ewa Z. , Petelczyc Luke
Published: July 2004

We developed the project presented in this paper for an undergraduate computer architecture course specifically aimed at non-engineering students. The project is designed to develop understanding of processor organisation at the functional unit level by building a series software execution driven simulators, from a single cycle sequential processor to a simple pipelined processor. The students are lead through the functional design process step by step, in a succession of carefully structured tasks. The project starts by building functional units of a processor. These units are then used to construct a single cycle processor, a multi cycle processor, and finally a pipelined processor with data hazard detection and forwarding. The main goal of the project is to give students a true insight into the fundamental ideas, which are the basis of the development of the modern microprocessor.