bluuebunny/crossref_metadata_2025 huggingface dataset:
Formal refinement patterns for goal-driven requirements elaboration
Authors: Darimont Robert , van Lamsweerde Axel
Published: July 2004

Requirements engineering is concerned with the identification of high-level goals to be achieved by the system envisioned, the refinement of such goals, the operationalization of goals into services and constraints, and the assignment of responsibilities for the resulting requirements to agents such as humans, devices and programs. Goal refinement and operationalization is a complex process which is not well supported by current requirements engineering technology. Ideally some form of formal support should be provided, but formal methods are difficult and costly to apply at this stage.This paper presents an approach to goal refinement and operationalization which is aimed at providing constructive formal support while hiding the underlying mathematics. The principle is to reuse generic refinement patterns from a library structured according to strengthening/weakening relationships among patterns. The patterns are once for all proved correct and complete. They can be used for guiding the refinement process or for pointing out missing elements in a refinement. The cost inherent to the use of a formal method is thus reduced significantly. Tactics are proposed to the requirements engineer for grounding pattern selection on semantic criteria.The approach is discussed in the context of the multi-paradigm language used in the KAOS method; this language has an external semantic net layer for capturing goals, constraints, agents, objects and actions together with their links, and an inner formal assertion layer that includes a real-time temporal logic for the specification of goals and constraints. Some frequent refinement patterns are high-lighted and illustrated through a variety of examples.The general principle is somewhat similar in spirit to the increasingly popular idea of design patterns, although it is grounded on a formal framework here.
Fifty years of progress in software engineering
Authors: Raccoon L. B. S.
Published: July 2004

In this paper, I describe a new outlook on the history of Software Engineering. I portray large-scale structures within Software Engineering to give a better understanding of the flow of history. I use these large-scale structures to reveal the steady, ongoing evolution of concepts, and show how they relate to the myriad whorls and eddies of change. I also have four smaller, more specific purposes in writing this paper.First, I want to point out that old ideas do not die. In The Mythical Man-Month after 20 Years, Brooks claims "the Waterfall Model is Wrong." But if the Waterfall model were wrong, we would stop arguing over it. Though the Waterfall model may not describe the whole truth, it describes an interesting structure that occurs in many well-defined projects and it will continue to describe this truth for a long time to come. I expect the Waterfall model will live on for the next one hundred years and more.Second, I want to show that the Chaos model, Chaos life cycle, Complexity Gap, and Chaos strategy are part of the natural evolution of Software Engineering. The Chaos model and strategy supersede, but do not contradict, the Waterfall and Spiral models, and the Stepwise Refinement strategy. They are more up to date because they express contemporary issues more effectively, and fit our contemporary situations better. The Chaos model, life cycle, and strategy are equally as important, but not better than, other concepts.Third, I compare the Chaos model, life cycle, and strategy to other models, life cycles, and strategies. This paper can be considered a comparison of the ideas presented in my papers about chaos with other ideas in the field. I avoided comparisons in my other papers because I wanted to define those ideas in their own terms and the comparisons did not further the new ideas.Fourth, I make a few predictions about the next ten years of Software Engineering. The large-scale structures described in this history provide a stronger base for understanding how software engineering will evolve in the future.This paper is laid out as follows. In the first section, I use the flow of water as a metaphor to describe the flow of progress in Software Engineering. I use the Water metaphor to show some of the structures within Software Engineering. The current work builds on top of the historical work, and future work will build on top of current work. In the remaining sections, I describe the waves, streams, and tides that portray the evolution of concepts and technologies in Software Engineering.
An overview of debugging tools
Authors: Law Rob
Published: July 2004

This paper reviews empirical studies on debugging models and the findings associated with these models. There is a discussion on the evolution of program slicing applied to program debugging and different generations of debugging tools are analyzed and criticized.Finally, a programming environment section provides examples of program maintenance tools.
A tool for the collection of industrial software metrics data
Authors: Aggarwal K. K.
Published: July 2004

A tool has been designed under Windows 3.1, which converts a 'C' software to its abridged version that lists program characteristics of interest to the metric researchers. These characteristics may be operators, operands lists, their frequency of occurrences, number of terminators, different types of control structures, internal and external variables, etc. This information may be useful for the researchers but prevents the reconstruction of the original source code.
Analysis of techniques in the assessment of ultra-reliable computerized systems
Authors: Morzenti Angelo , Schreiber Fabio A.
Published: July 2004

A wide gap exists between the dependability figures, required by standardization committees for life-critical computer applications, and the current state-of-art in techniques to provide and assess them. In this paper we make a quick review of the best suited methodologies for each phase of the system life-cycle. We argue that the traditional view, which distinguishes between the behaviour of hardware and software components, should be clarified by separating the logical activities in the specification and in the design phases, which can be related both to hardware and to software, and the physical defects and operation stress, which only affect hardware.
Automatic transformation from data flow diagram to structure chart
Authors: Guo Minyi
Published: July 2004

The software development methodologies---structured analysis and structured design techniques are considered as the most popular and successful. But the process of transforming from structured software specification to structured design document is a challengingly intelligent activity. In this paper, we attempt to solve this problem automatically in our CASE tool, called CAST (Computer-Aided Structured Transformation). We propose a description language as a common machinery for the representation of various structured tools. Two kinds of algorithms which correspond to two structured analysis methods called transform analysis and transaction analysis, used to produce structure charts from data flow diagrams, are presented. The architecture of CAST is also described in the paper.
Implementing inheritance in operational graphical languages
Authors: Agarwal Rakesh , Bruno Giorgio
Published: July 2004

System engineering development methods and automation techniques are required to manage the complexity inherent in the design of large computer based systems and to provide an efficient means for reusing the system by means of inheritance.Growing interest is being shown in operational models, i.e. models that can be executed using a suitable support environment. Most operational models are graphical and can be considered as high-level programs which are developed using high-level modeling languages. Generally speaking, while the OO approach has reached a good maturity at the programming level (although differences in individual languages are not negligible) there is no clear consensus on how it can be extended to the design and analysis phases.These artificial discontinuities can be eliminated if a single modeling language is used which is
operational.
The operational approach eliminates the scope and semantic discontinuities in the development process by using a single, integrated, formal set of modeling abstractions to create a given executable model.It was to address these problems and provide advanced software architectural features, that
O
3
ML was developed by us. Combining the concept of Operational, OO and Modeling we get a
modeling language
which we refer to as Operational Object-Oriented Modeling Language (
O
3
ML) that provides the basic vocabulary used to express both domain knowledge and prototyping ideas.
Teaching social and ethical issues in the literacy course
Authors: Turk Jane , Wiley Samuel J.
Published: July 2004

A growing number of colleges and universities educate their computer science
majors
in social and ethical issues relating to computers. This article presents the case for incorporating consciousness of social and ethical issues of computing into the
computer literacy
course. The article examines our ethical obligations as professional educators in this area. It notes the focus provided by Computing Curriculum 91 and CSAB on social and ethical issues for majors. It suggests social and ethical issues related to topics in computer competency and describes specific strategies used to incorporate social and ethical issues in a computer literacy course at one university.
A collection of tools for making automata theory and formal languages come alive
Authors: Rodger Susan H. , Bilska Anna O. , Leider Kenneth H. , Procopiuc Magdalena , Procopiuc Octavian , Salemme Jason R. , Tsang Edwin
Published: July 2004

We present a collection of new and enhanced tools for experimenting with concepts in formal languages and automata theory. New tools, written in Java, include JFLAP for creating and simulating finite automata, pushdown automata and Turing machines; Pâté for parsing restricted and unrestricted grammars and transforming context-free grammars to Chomsky Normal Form; and PumpLemma for proving specific languages are not regular. Enhancements to previous tools LLparse and LRparse, instructional tools for parsing LL(1) and LR(1) grammars, include parsing LL(2) grammars, displaying parse trees, and parsing any context-free grammar with conflict resolution.
A visual development environment for multi-lingual curricula
Authors: Hendrix T. Dean , Barowski Larry A. , Cross James H.
Published: July 2004

Although a computer science curriculum may use a single language as its "core" language, many curricula require students to learn and use multiple languages for course or practicum work. Students benefit from the exposure to other languages and other language models. However, a problem arising from the multi-lingual nature of a curriculum is the necessity to learn and use different development environments and language front-ends. GRASP (Graphical Representations of Algorithms, Structures, and Processes) is a software engineering tool currently being successfully utilized as a common development environment for the multi-lingual computer science curriculum at Auburn University. Besides providing a common front-end for different languages, GRASP also provides automated visualization of source code in the form of the control structure diagram and the complexity profile graph. This paper describes GRASP and its current use in the computer science curriculum. GRASP is freely available via the Internet at the following URL:
http://www.eng.auburn.edu/grasp
Using student-built algorithm animations as learning aids
Authors: Stasko John T.
Published: July 2004

The typical application of algorithm animation to assist instruction involves students viewing already prepared animations. An alternative strategy is to have the students themselves construct animations of algorithms. The Samba algorithm animation tool fosters such student-built animations. Samba was used in an undergraduate algorithms course in which students constructed algorithm animations as regular class assignments. This article describes Samba and documents our experiences using it in the algorithms course. Student reaction to the animation assignments was very positive, and the students appeared to learn the pertinent algorithms extremely well.
Function objects, function templates, and passage by behavior in C++
Authors: Rasala Richard
Published: July 2004

Passing functions and function objects to general purpose routines is a powerful abstraction mechanism that should be taught in freshman computer science. In C++, a "function" can be defined directly by the user or by a library or can be defined indirectly via operator() as a member function of a class. It is not obvious how to treat these "functions" in a uniform manner. We will show how function templates in C++ provide an elegant and teachable mechanism for passing entities with functional behavior as arguments to other functions.
A practical approach to reinforcing concepts in introductory operating systems
Authors: Wagner Thomas D. , Ressler Eugene K.
Published: July 2004

The challenge of including both theory and practical experience to reinforce the concepts of theory in Introductory Operating Systems is discussed. The traditional approaches to answering this challenge are presented. A practical approach that uses straightforward programming problems rather than problems that involve modification of an existing operating system is described. Examples of the types of problems used are presented and experience with the proposed approach is described.
CALOS
Authors: Goldberg Murray W.
Published: July 2004

This paper describes the outcome of an experiment in Computer-Aided Learning (CAL) for Operating Systems using the World-Wide Web (WWW). The purpose of the experiment is to evaluate WWW-based course delivery both in terms of academic performance and in terms of student acceptance. A complete WWW-based offering of an existing third-year university course in Computer Science was produced. Students enrolled in the course were divided into three groups: 1) those taking the course using only the WWW-based resource (no lectures), 2) those taking the course by attending lectures (no access to the WWW-based resource), and 3) those with access to both lectures and the WWW-based resource.Academic results were evaluated and qualitative student impressions were solicited. In general the WWW-only method of course delivery was an equal success compared to the lecture-only delivery, both in terms of academic results and in terms of student acceptance. On average, students in the combined lecture and WWW-based delivery performed better academically than students in the other groups.
Examining student learning of computer science
Authors: Greening Tony
Published: July 2004

Student examination performance in a third-year module, "
Communications, Networks and Distributed Systems
" (CNDS), is analyzed in terms of different responses to questions which required qualitative versus quantitative answers. This is matched to the results of a student survey conducted in the first lecture, in which students were asked about what they would hope to gain from the module. The observations indicate that there are significant differences in the manner in which students learn computer science, and that this may correlate with expectations about desired learning outcomes. This impacts upon aspects of course design and delivery, as well as approaches to assessment (and examination design in particular). It also suggests that examinations may be regarded as offering new avenues of feedback on student learning in addition to fulfilling traditional assessment related roles.
Introductory computer science for general education
Authors: McFall Ryan , Stegink Gordon
Published: July 2004

Many colleges and universities are experiencing the need to offer an introductory computer science course that meets some but perhaps not all the guidelines suggested for a CS 1 course. This course frequently meets institutional general education requirements and must be more than a literacy course.We discuss the implementation of such a course at Hope College. We outline the goals of the course and some novel features of the implementation, including an emphasis on graphics. We give examples of our approach to laboratories. Finally we show how we utilize the World Wide Web as a substitute for a textbook and for course administration.
WinRDBI
Authors: Dietrich Suzanne W. , Eckert Eric , Piscator Kevin
Published: July 2004

RDBI is an educational tool that provides students with the capability to test their understanding of the formal relational query languages (relational algebra, domain relational calculus and tuple relational calculus) and the industry standard query language SQL. Although RDBI is an integral part of the database management courses at a number of universities, it is unavailable to those universities that do not have a license for the software product in which RDBI is implemented. WinRDBI, a version of RDBI for Windows, removes this limitation by increasing the availability of the educational tool to a standard Windows platform. Another advantage of WinRDBI is its graphical user interface, providing the student with a more intuitive interface than the command line interface of RDBI. This paper describes the architecture and user interface of WinRDBI. The features of WinRDBI are also illustrated using nontrivial examples from a popular database text. Although formal relational query languages do not provide inherent support for aggregation, these examples illustrate how to write queries in the formal languages to support (a limited form of) counting and minimum/maximum queries.
Avoiding object misconceptions
Authors: Holland Simon , Griffiths Robert , Woodman Mark
Published: July 2004

This paper identifies and describes a number of misconceptions observed in students learning about object technology. It identifies simple, concrete, measures course designers and teachers can take to avoid these misconceptions arising. The context for this work centres on an introductory undergraduate course and a postgraduate course. Both these courses are taught by distance education. These courses both use Smalltalk as an introduction to object technology. More particularly, the undergraduate course uses Smalltalk as a first programming language.Distance education can limit the amount and speed of individual feedback that can be given in the early stages of learning. For this reason, particular attention has been paid to characterizing measures for avoiding elementary misconceptions seen in beginning learners. At the same time we also address some misconceptions observed in postgraduate students. The pedagogical issues discussed are of particular importance when devising an extended series of examples for teaching or assessment, or when designing a visual microworld to be used for teaching purposes.
Computer science for the artist
Authors: King L. A. Smith , Barr John
Published: July 2004

Computers are faster and cheaper than ever before and at the same time user interface advances make powerful applications more accessible to the non-computer scientist. In a diverse range of industries, it is now essential for non-computer scientists to create, modify and interact with sophisticated computer applications. Although improved interfaces like high-level scripting languages and visual programming environments, have changed the skill set needed to use the computer, a conceptual understanding of computing and computer interfaces is still required. The very advances allowing direct computer use by non-computer scientists have actually increased the need for computer literacy. Thus computer science departments should expand and enhance course offerings to give non-majors the conceptual understanding and skills they need to become sophisticated users/developers in their particular fields. This paper describes a series of courses developed at Ithaca College that are designed to provide multimedia programming skills and concepts to liberal arts majors.
The locker metaphor to teach dynamic memory
Authors: Jiménez-Peris Richardo , Pareja-Flores Cristóbal , Patiño-Martínez Marta , Velázquez-Iturbide J. Ángel
Published: July 2004

Some students experience difficulties when first introduced to dynamic memory. The goal of this paper is to present an analogy between dynamic memory programming and a real-world example that will help students in understanding the underlying concepts behind dynamic memory: a left-luggage room with lockers.
A prototype for a data communications laboratory
Authors: Levin Martin H.
Published: July 2004

This paper describes the development of a small laboratory to serve as a prototype for a Data Communications Laboratory. We discuss the planning, construction, capabilities and use of the prototype lab by our three data communications courses. The capabilities and use of the lab in entry level microcomputer communications course, the entry level course, is demonstrated and explained, along with our plans for a larger lab in the near future based on a successful NSF-ILI grant request for additional equipment.
Collaborative learning
Authors: Walker Henry M.
Published: July 2004

Since Fall, 1992, the author has used techniques of collaborative learning in his sections of CS1 at both Grinnell College and The University of Texas at Austin. These experiments have been successful by various measures: drop rates are very low, students perform well on tests, student motivation and enthusiasm are very high, and the class covers about 20% more material during the semester. This paper describes the approach that has evolved through several iterations of this course.
Parallel programming using public domain software
Authors: Burkhart Helmar
Published: July 2004

This paper reports on experiences of using public domain software for teaching parallel programming. We describe the three packages used, namely
superpascal
,
pvm
, and
alwan
and assess their specific strengths and weaknesses. We describe our course activities to teach parallel programming and summarize our experiences made.
The gestalt of scientific programming
Authors: Zachary Joseph L.
Published: July 2004

The process of solving a problem in computational science neither begins nor ends with designing and writing a computer program. The process entails isolating the problem, devising a mathematical model, identifying a computational method, producing an implementation, and assessing the solution. Unfortunately, the introductory programming courses taken by science and engineering students frequently focus only on implementation issues. As a result, such students are often ill-equipped to solve computational problems.We have created a course and written an accompanying textbook that present an introduction to scientific programming. Both are organized around the process for solving computational science problems sketched above. In this paper we illustrate this approach by describing two representative problems from the course and textbook. Along the way, we present Java applets that were designed to illustrate some of the ideas that underlie the two problems.
AnLex and AnSin
Authors: Patiño-Martínez Marta , Castelló-Gómez J. Ignacio , Jiménez-Peris Ricardo
Published: July 2004

The study of compiler generators is an integral part of compiler construction, and for this reason it is customary to have a programming project entirely devoted to it in compiler courses. There are many compilers generators, but their use in a compiler course presents several problems (e.g. the parsers generated are difficult to understand and to debug). In this paper, we describe such problems and present a compiler generator system, AnLex-AnSin, that solves these problems, and can thus be used in compiler programming projects.
Introducing fixed-point iteration early in a compiler course
Authors: Hailperin Max
Published: July 2004

When teaching a course in compiler design, it is conventional to introduce the iterative calculation of least fixed points quite late in the course, in the guise of iterative data-flow analysis. In this paper I point out that the same mathematical and algorithmic ideas can be introduced much earlier, in the parsing portion of the course, as an explanation of the standard algorithm for computing the
First
sets of a context-free grammar. Doing so not only renders these techniques more familiar when they re-appear in data-flow analysis, it also provides a more sound foundation for the
First
algorithm than is typically offered. Moreover, these techniques deserve increased curricular prominence because they naturally lead to proofs of correctness for general non-deterministic algorithms that subsume multiple deterministic algorithms.
STAMPS
Authors: Livesey Mike
Published: July 2004

This paper describes the STAMPS software workbench that supports Honours level computer architecture teaching. STAMPS was developed in response to a need perceived from experience of such teaching. It is a hierarchically structured CPU simulator that can be customised to any architecture and implementation of that architecture.STAMPS is written as a Tcl/wish application. Tcl facilitates interaction with the file system, simple naming conventions and highly flexible user interaction. STAMPS runs on any Unix platform.
Using interaction networks for visualisation of message passing
Authors: Ashton Paul
Published: July 2004

Understanding software structured as separate programs that communicate via message passing requires understanding how the various programs interact with each other, as well as understanding the individual programs in isolation. An interaction network display shows in a visual way message passing within and between programs. We have implemented an interaction network monitor for the MINIX operating system, for use in showing students how the system programs and processes of MINIX interact to provide operating system services. We give three examples to demonstrate the insights into message-based systems that can be gained from studying interaction network displays.
Megaprogramming education
Authors: Haddad Hisham , Tesser Herbert , Wartik Steven
Published: July 2004

In the computer science field, educators face several obstacles when attempting to introduce rigorous software engineering concepts and practices into the curriculum. This paper addresses the issue of software engineering education and the role of megaprogramming in introductory courses for high school and college students. We highlight the need for, and the initial effort in megaprogramming education. We provide a brief description of developed materials and a proposed approach to integrate megaprogramming into high school computer science curriculum.
Report on the annual survey of departments offering CSAC/CSAB-accredited computer science degree programs
Authors: McCauley Renée A. , Manaris Bill Z.
Published: July 2004

This paper presents results of a survey of departments offering accredited Computer Science degree programs. It discusses demographic information related to curricula, faculty, and students for all such programs, and identifies various trends based on this data. These results are of interest and use to all accredited and non-accredited departments alike, since it provides the information necessary to monitor and compare individual degree programs to other programs in the nation in terms of faculty composition, student enrollment and graduation rates, faculty salaries, and curriculum issues.
Broadening the computer science curriculum
Authors: Robergé James , Carlson C. R.
Published: July 2004

Too often, students in undergraduate computer science programs come to equate computer science with the "nuts and bolts" of the field---programming, data structures, algorithms, operating systems, programming languages and so forth. If we are to attract students to computer science and produce graduates who will excel in the profession, we must broaden our students' perspective on our discipline. In this paper, we examine an initiative that seeks to broaden the undergraduate computer science experience by introducing three new elements into the curriculum: a first-year experience that focuses on the challenges of computer science, a fourth-year experience that focuses on the initial stages of the software design process, and a student portfolio that unifies the existing curriculum, broadens its content, and provides us with a mechanism for assessing the growth of our students' technical and non-technical skills.
Improving education quality, a full scale study
Authors: Berglund Anders , Daniels Mats
Published: July 2004

We now and then make changes to our courses and how we teach or examine them. This is often done in isolation from other courses that the students take. In this paper we report on experiences made in a coordinated study concerning examination methods. The target group was 60 students from the Systems branch of the Engineering Physics study program. We changed all three courses they took during the first ten weeks of the spring semester 1996. The changes were in short: replace the final exam by weekly assignments, introduce seminars as a method of examination, and in the cases where a written exam was kept, the main focus of the questions were changed to showing understanding, ability to analyze and synthesize.Our experiences in this study clearly show that changing examination is a tool for changing the way our students work, and thus for improving the quality of the education.
Gender imbalance in computer science programs, etiology and amelioration (panel)
Authors: Freeman Elizabeth , Hupfer Susanne , Lang Catherine , Morelli Ralph , Pinto Domenick J. , Van Scoy Frances L. , Adams Sandra Honda
Published: July 2004

As a female computer science educator, I've watched with growing alarm the drop in enrollment in our Computer Science programs from a ratio of 1:1 of males and females in 1983, to a current ratio of 5:1. The lack of interest of female students in Computer Science is still a very serious problem. As educators we should all be watching our own campus and addressing this problem. The panelists assembled from various institutions will address the issues of gender imbalance and relate their experiences in implementing solutions to counter this problem. Two of the panelist will discuss utilization of the World Wide Web addressing reasons for creating both Web sites. As long as this gender imbalance exists in our schools we need to continue our dialog to share and develop new ideas to encourage female participation in Computer Science Programs. The audience will be welcomed to participate in a larger group discussion.
Using multimedia communication technologies in distance learning
Authors: Robles Tomás , Fernández David , Pastor Encarna , Alamillo Santiago
Published: July 2004

This paper describes pilot experiences of distance learning using videoconference over the public Integrated Services Digital Network (ISDN). Graduate and postgraduate courses of the Technical University of Madrid (Telecommunication Engineers) form the educational scenario chosen for the experiences. Several phases were defined to carry out the experiments, each one centred around different students/subjects profiles. The first phase has been recently finished and it has been evaluated with interesting results from a pedagogical point of view. Organisational, technical and economical aspects has also been evaluated with the aim of extending these experiences to a larger scale.
Improving discrete mathematics and algorithms curricula with
LINK
Authors: Berry Jonathan
Published: July 2004

This paper introduces the
LINK
system as an educational tool which can be used to visualize and experiment with discrete algorithms. An extended example demonstrates the flexibility of the system in the context of a fundamental graph algorithm: finding the strongly connected components of a directed graph.
Excel as an algorithm animation environment
Authors: Rautama E. , Sutinen E. , Tarhio J.
Published: July 2004

Understanding of fundamental algorithms and designing algorithms for a novel problem are basic skills in Computer Science. Animation is a useful aid in both these areas. We show how to animate algorithms with Microsoft Excel using data visualization and macro programming features of Excel. The user writes an algorithm using the Visual Basic programming language of Excel and defines charts visualizing dynamically the data structures of the algorithm. This approach is suitable especially for small-scale animation, e.g. for course assignments in Computer Science.
A genetic algorithms tutorial tool for numerical function optimisation
Authors: Burke E. K. , Varley D. B.
Published: July 2004

The field of Genetic Algorithms has grown into a huge area over the last few years. Genetic Algorithms are adaptive methods, which can be used to solve search and optimisation problems over a period of generations, based upon the principles of natural selection and survival of the fittest. This paper describes an innovative tool to introduce the basics of the subject of Genetic Algorithms called GAVIn (Genetic Algorithms Visual Interface). It focuses on the domain of numerical function optimisation problems as these form a good basis for learning and operator comparison. The other problem domains are too varied and problem dependent to form a general, robust learning tool.
Instructional software for closed laboratories in CS1
Authors: Beheshti Mohsen , Waller Bill
Published: July 2004

The purpose of this paper is to describe the instructional software that is used on our campus to support closed laboratories in CS1. In addition to promoting the general benefits gained from closed labs, it has been highly successful at: encouraging collaborative learning; providing a consistent and user-friendly lab environment, providing instructors a software tool for creating new labs or editing existing labs; providing instructors a means for easily adapting lab materials to individual preferences; and permitting instructors to integrate multimedia features into laboratories.
Integrating design and simulation into a computer architecture course
Authors: Knox Deborah L.
Published: July 2004

This paper describes our experiences with closed laboratories in a computer architecture course and highlights the development of a capstone project. We advocate the use of software as a cost effective means of supporting analysis, design, and experimentation. Improvements to the course in regards to content, environment for learning, student perception, skills accomplished and retained, and instructor involvement are outlined. Several labs are summarized, including the capstone project tying together all aspects of machine organization. We conclude that integrating design education into computer science with the logic simulator lab approach is worthy of our continued efforts.
A pedagogical pattern for bringing service into the curriculum via the web
Authors: Erickson Carl , Leidig Paul
Published: July 2004

The Web reduces the economic hurdles of publishing a message to a large audience. This paper documents a pedagogical pattern to integrate community service with the curriculum. Students in two different computer science courses teamed up to create websites for local non profit organizations (NPOs). The projects provided CS majors with real customers, the challenge of working on an interdisciplinary team, an opportunity for community service, and an opportunity to learn very new technologies. For their part the NPOs gained a new means of communicating their missions to the world. We believe the potential for reuse of this pattern is high and could benefit other schools and communities.
Distributed algorithms in Java
Authors: Ben-Ari Mordechai
Published: July 2004

We show how Java can be used to develop portable implementations of distributed algorithms for class demonstrations and laboratory exploration. The programs can be used in two modes: (a) TCP/IP communications over a net, or (b) applet-to-applet communications on a single HTML page. The latter mode is important during program development and can also be used if your lab malfunctions or for homework assignments. Programs were written for four distributed algorithms: Byzantine generals, Ricart-Agrawala mutual exclusion, Dijkstra-Scholten termination and Chandy-Lamport snapshots.
Design and realization of an interactive multimedia server in education
Authors: Coninx K. , Daems B. , Van Reeth F. , Flerackers E.
Published: July 2004

The European project ELECTRA is concerned with the introduction of multimedia / telematics support to enhance the accessibility (local, regional and international) of learning material and to promote collaborative work. For the purpose of this paper we concentrate on two workpackages in the Limburg University Centre. The Interactive Multimedia Server workpackage focuses on the design of a generic platform for the integration of different types of information related to the learning process. Special attention is given to management, integration and accessibility of study material in an electronic environment. The other workpackage investigates the use of the interactive multimedia server in Medicine education.
Recursion and grammars for CS2
Authors: Proulx Viera K.
Published: July 2004

A programming exercise on recursion in which students create drawings of simple and bracketed Lindenmayer Systems provides a context for exploring additional computer science concepts. The resulting drawings give students a better understanding of the power of recursion as well as the rate of growth of time complexity with multiple successive recursive calls. We describe the exercise, the concepts that need to be addressed to solve the problems, and the results of using this exercise in our classes.
Multi-media integrated into CS 2
Authors: Wolz Ursula , Domen Daniel , McAuliffe Michael
Published: July 2004

An interactive children's story is presented as a unifying class project for CS 2. Curricular topics include: data and algorithm abstraction, project dynamics (team work, software engineering and ethics), multi-media techniques, and hypermedia story telling. We encompass alternative learning styles by fostering collaborative team work, and promoting the big picture over esoteric detail. Students receive a detailed design document, extensive code libraries, and graphic, sound and video files. A story board gives them ample room for individual creativity and whimsy. The project is implemented in C++. This paper describes curricular goals, articulates management concerns and summarizes our past experiences.
On teaching computer literacy to future secondary school teachers
Authors: Lee Greg C. , Wu Chen-Chih
Published: July 2004

This paper discusses our experience in teaching computer literacy classes to non-majors with a future career as secondary school teachers. The backgrounds of the students, our teaching philosophy, course organization and conduction as well as the feedbacks from our students are detailed. From the feedbacks it can be seen that the central goal of computer and application literacy is accomplished. Furthermore, students' perceptions of computers has turned from negative to positive.
A proposal for integrated software engineering education
Authors: Grove Ralph F.
Published: July 2004

This paper describes a proposal to strengthen the coverage of software engineering within the undergraduate CS curriculum by integrating coverage of software tools, methodologies, and practices into core courses and by providing appropriate resources for instructors. The goal of the proposal is to improve technical readiness of CS graduates for the 21
st
-century software development workforce by providing an exposure throughout the CS curriculum to modern project management practices and tools, and by developing in students skills necessary to participate in software development projects.
E pluribus unum
Authors: de Vivo Gabriela O. , de Vivo Marco , Isern Germinal
Published: July 2004

Usually legacies act as strong amalgamating forces and are thus beneficial to systems and theories. However, as time passes through, even legacies must be reviewed in order to benefit from changes. Although several sound models has been produced by software engineers in the last 25 years, a large amount of software is still produced and maintained using aged paradigms and methods (if any) and COBOL/FORTRAN generation tools. The underlying idea seems to be "Why change it if it works?". Nevertheless it seems too that time for changes has come. The OO paradigm is really strong and useful and has been showed appropriate for almost any conceivable software system. Besides, actual programmers and analysts are formed under this paradigm. So it seems foreseeable a consistent conversion to OO paradigm. What still doesn't seem to be clear is how adequate are the actual OOP languages to support the paradigm, and what is the comparative effort involved in mastering them and their associated environments. This paper reports the heuristics and observations resulting from a simple experiment formulated to explore how adequate are the languages C++, Eiffel, and Ada 95 to implement OO designed systems.
FASRS—demo package for Fourier analysis of stationary random signals
Authors: Jovanovic-Dolecek Gordana
Published: July 2004

This paper presents software package FASRS which is developed in MATLAB and is meant for use as an interactive learning tool for the bases of Fourier analysis of stationary random signals. Two main approaches are demonstrated. One approach, which is referred to as Periodogram method is based on direct Fourier transformation of signal. The second approach, Autocorrelation method, is based on the Fourier transform of the estimation of the autocovariance sequence of the signal.
A survey into the relevance and adequacy of training in systems analysis and design
Authors: Larmour R.
Published: July 2004

A questionnaire was designed to cover the areas of systems analysis and design (SAD) which staff in Northern Ireland currently work on, the extent of training the person has had in those areas, and there assessment of the adequacy of any training given. The questionnaire was distributed to both commercial firms and to the civil service. The total replies were 150 - civil service(104), non-civil service(46). The survey showed that training in SAD was concentrated in certain areas - those such as systems and data modeling. Other areas such as interview techniques and sampling of documents are not equally as well covered in training. Student assessment of the training provided varied significantly. The ease with which certain aspects of SAD training courses can be developed as opposed to others is discussed and the important imbalance in the coverage of training provisioned is highlighted.
Students asking questions
Authors: Barnes David
Published: July 2004

By providing a means to ask questions anonymously, we provide a non-threatening environment in which students are encouraged to fully understand and criticise their assignments. As well as providing practical assistance for those who are struggling with course work, it demonstrates a practical reinforcement of ideas that are commonly taught in courses on software engineering, but it does so in a context that they can directly relate to - their desire to achieve good grades. The approach is based around the use of an HTML form to enable the anonymous submission of questions to staff and the dynamic refinement of assignment specifications. Examples of its use in a course on object-oriented design and C++ are given.
The em88110
Authors: Pérez Villadeamigo José M. , de la Fuente Santiago Rodríguez , Cavanillas Rafael Méndez , García Clemente M. Isabel
Published: July 2004

Assembly programming is a very important topic to teach computer architecture. Current computers include special techniques to improve performance such as pipeline and multiple instruction issue per cycle. But these kinds of computers are difficult to use in laboratory works because of the great amount of details of the target computer architecture that are not relevant to beginners. Hence, we decided to build a configurable emulator of a superscalar processor to create a wide set of laboratory works, from the simplest one that uses the computer as a serial processor to the most complex that uses the full set of performance improvements of a superscalar computer. Most of the computer parameters can be established by the student or the teacher providing a virtual machine that is easier to use. Students can do their laboratory work without taking into account the additional problems generated by a real computer.
Constructing compact models of concurrent Java programs
Authors: Corbett James C.
Published: July 2004

Finite-state verification technology (e.g., model checking) provides a powerful means to detect concurrency errors, which are often subtle and difficult to reproduce. Nevertheless, widespread use of this technology by developers is unlikely until tools provide automated support for extracting the required finite-state models directly from program source. In this paper, we explore the extraction of compact concurrency models from Java code. In particular, we show how static pointer analysis, which has traditionally been used for computing alias information in optimizers, can be used to greatly reduce the size of finite-state models of concurrent Java programs.
On random and partition testing
Authors: Ntafos Simeon
Published: July 2004

There have been many comparisons of random and partition testing. Proportional partition testing has been suggested as the optimum way to perform partition testing. In this paper we show that this might not be so and discuss some of the problems with previous studies. We look at the expected cost of failures as a way to evaluate the effectiveness of testing strategies and use it to compare random testing, uniform partition testing and proportional partition testing. Also, we introduce partition testing strategies that try to take the cost of failures into account and present some results on their effectiveness.