bluuebunny/crossref_metadata_2025 huggingface dataset:
A real-time microprocessor debugging technique
Authors: Hill Charles R.
Published: July 2004

This note describes RED, a remotely executed debugger capable of generating a real-time source level trace history of a high level language program executing on a microprocessor. The trace history consists of a display of the source statements of each basic block executed, annotated by the time at which execution of that block began. Basic blocks are traced rather than statements to reduce sampling bandwidth requirements while still retaining the ability to record the essential logical flow of programs. RED is intended to assist in debugging stand-alone high level language process control programs with real-time constraints.

We outline two possible implementation schemes for generating the real-time trace history. In both, a "debugging co-processor" collects in a history buffer the values of the program counter (PC) and the corresponding value of a clock as each basic block begins execution. The debugger, which runs on the processor hosting the compiler and has access to the co-processor over a fast link, reconstructs a source level trace from the PC-time pairs in the history buffer. In one scheme, the language compiler emits an extra instruction at the beginning of each basic block in the program to output the value of the program counter to a parallel port connected to the debug processor. The second method makes use of an extended target memory space to provide tag bits denoting basic blocks. When an instruction is fetched, the debug processor detects the presence of the tag bits and buffers up the value of the corresponding program counter and time. The first method is simpler to implement, requiring only conventional, usually straightforward hardware additions to the target, but requires the execution overhead of the extra instructions. In both cases the debugger itself runs on the host processor and has access to tables generated during compile time of the source program.
An interactive high-level debugger for control-flow optimized programs
Authors: Zellweger Polle T.
Published: July 2004

The transformations performed by an optimizing compiler have traditionally impeded interactive debugging in source language terms. A prototype system called Navigator has been developed for debugging optimized programs written in Cedar, an Algol-like language. Navigator can be used to monitor program execution flow in the presence of two optimizations: inline procedure expansion and cross-jumping (merging identical tails of code paths that join). This paper describes the problems that these two optimizations create for debugging and Navigator's solutions to these problems. The selected approach collects extra information during the optimization phases of compilation. At runtime, Navigator uses the additional information to hide the effects of the optimizations from the programmer.
Summary of evaluation and comments
Authors: Johnson Mark Scott
Published: July 2004

On the last day of the Symposium an evaluation form was distributed to all participants. About half responded; their comments are summarized here.

Three-quarters of those responding felt the Symposium met their expectations well or very well. Important topics reported as being not discussed or not sufficiently discussed included real-time debugging, practical debugging strategies, implementation issues for production debuggers, human factors, and architectural support for debugging.
Mappings for rapid prototyping
Authors: Feather Martin S.
Published: July 2004

The transformational methodology for software development is adapted to perform rapid conversion of specifications into prototypes. This makes feasible testing of specifications to observe their behaviours and assuring that specifications can indeed be implemented.The approach is centered on gathering techniques to map each type of specification language construct into a reasonably efficient implementation. Instances of these constructs in an actual specification may then serve as the focal points for the conversion process.
Rapid prototyping of information management systems
Authors: Blum Bruce I. , Houghton Raymond C.
Published: July 2004

Rapid prototyping is especially effective when implementing interactive information management systems. With the right tools, the development process for these systems involves the generation of successive prototypes where each successor is closer to the user requirement. The final prototype becomes either the production system or a production subsystem which is integrated into the total system. The tools used to generate successive prototypes are called application generators and program generators. There are several software engineering issues addressed by these tools.
A study in prototyping
Authors: Gehani N. H.
Published: July 2004

A prototype electronic form system was implemented to test the feasibility of a high level form definition mechanism. This mechanism is based on the idea of abstract data types in programming languages. In this paper I will briefly discuss prototypes in general and then describe the prototype electronic form system --- specific objectives, design decisions and evaluation.Rapid construction of the prototype was facilitated by tools on the UNIX™ operating system that helped manage frequent and quick changes to software. The prototype has proved invaluable in providing a better understanding of the facilities that should be included in a form definition language and of the issues in implementing it.
System sketching
Authors: McCoyd Gerard C. , Mitchell John R.
Published: July 2004

Rapid prototypes are important tools to aid users in formulating their software requirements. The system sketch is a rapid prototype which shows the user the functions of the system he has specified.In this paper we present a system sketch produced by a processor written in LISP which interprets software requirements stated in an expanded PSL-like requirements language. Discussions of the language and the processor are presented.
Use of annotated schemes for developing prototype programs
Authors: Ramanathan J. , Shubra C. J.
Published: July 2004

Reusable components or patterns of programming are used here as a means of generating prototypes. The challenge in identifying existing patterns was in striking a balance between a few patterns that are too flexible to really save programmer effort, and numerous patterns that are too narrowly applicable. A further challenge was to find a way of tuning a pattern to reflect the details of a specific application.A pattern is defined to have a) an I/O specification, b) control structure, c) and a generic problem/solution description. The domain dependent generic problem/solution description serves to communicate general semantic information to the prototype developer familiar with the domain. The patterns presented here were culled from case studies involving over 200 programs in the file processing domain. These patterns have been demonstrated to be useful.
Models as executable designs
Authors: Stavely Allan M.
Published: July 2004

If a design is viewed as a model of the eventual implementation, and if it is expressed in a well-defined design notation, it can be made executable and treated as a prototype which reflects whatever internal details are expressed in the design. However, to turn this technique into a way of constructing a prototype whose externally-observable behavior is meaningful from the user's point of view, methods must first be developed for the rapid prototyping of user interfaces.
Software tools
Authors: Kernighan B. W. , Plauger P. J.
Published: July 2004

Building on the work of others is the only way to make substantial progress in any field. Yet computer programming continues as a cottage industry because programmers insist on reinventing programs for each new application, instead of using what already exists. We must encourage a way of packaging programs so that they can be
perceived
as standard tools, each performing its specialized task sufficiently well and interfacing to other tools so conveniently that programmers seldom feel any need to make their own version from scratch.In this paper we show how programmers can view substantial parts of what they do as tool building and tool using. By studying some specific examples of general purpose tools, we show how programs can be packaged as tools, so other programmers will use them in preference to building their own. We also comment on the sort of programming environment which seems most hospitable to the development and use of tools.
Masters curriculum in software engineering
Authors: Fairley Richard E.
Published: July 2004

This paper is a status report on the curricular efforts of the IEEE Computer Society's subcommittee on software engineering education. The first draft of a proposed Masters program in software engineering is presented, as is the undergraduate preparation required for admission to the program. Potential implementation problems are discussed, and future plans are mentioned.
Some verification problems in Pascal-like languages
Authors: Giordano Joseph V.
Published: July 2004

This paper discusses the design of programming languages suitable for program verification, considering in particular Pascal, Euclid, Gypsy, and Ada. Basing our discussion on programming capabilities found in Pascal, we evaluate (a) how well each language solves or reduces verification problems such as name visibility, aliasing, relative completeness, side effects and (b) how the language's treatment of these verification problems impacts other language design concerns.
The Ada language and environment
Authors: Wegner Peter
Published: July 2004

A brief outline of the history and current status of Ada is followed by a description of salient language features and a discussion of the proposed Ada environment. Language-level support of modularity may result in substantially cheaper program development and maintenance, and will have a profound effect on both programming style and methods of teaching. Environment requirements include a data base for program development and maintenance, a kernel which is the interface for portability, and a minimal toolset which provides a common base for individual environments. The UNIX approach could be used as a starting point for developing Ada environments, but would have to be modified to reflect military embedded computer requirements and the fact that Ada rather than C would be the system programming language. It is predicted that Ada usage will overtake Fortran usage by 1995.
Designing software without backtracking
Authors: Mili Ali
Published: July 2004

The research effort reported on here is an attempt to identify the cause of backtracking in Software design and to present a sketch of remedies to it.
Using binary search on a linked list
Authors: Khosraviyani Firooz
Published: July 2004

In this article a variation of binary search applicable to a linked list structure is examined. There are no additional data structure properties imposed on the list; that is the list may be singly or multiply linked, but it is not required that the list be represented as a binary tree. The process can be used with improved efficiency in place of linear search on a linked list where introducing additional data structures complexity on the list is not desirable.This procedure seems appropriate for inclusion in data structures courses where searching and sorting are discussed. The texts on data structures cover the binary search on a fixed length sequence, but the general consensus is that there is no advantage in trying to implement the binary search process on linked lists. One possible exception in this regard, where no details are provided, is [2, page 147].
Dining philosophers revisited
Authors: Gingras Armando R.
Published: July 2004

In 1965 Dijkstra posed and solved the Dining Philosophers problem. Since then the problem has become a classic test case for concurrency mechnisms and an example often discussed in operating systems courses. Two theorems prove the correctness of seatings where all philosophers always prefer to pick up a fork with a particular hand first. This note shows the subtlety required to solve the problem by showing that a recently published solution is incorrect. A correct solution is provided.
An academic relational algebra database management system
Authors: Logan Paula M. , Hale Clifford W. , Atkins John M.
Published: July 2004

This paper describes a relational algebra database management system written by two graduate students at West Virginia University. The system is designed to be used in an undergraduate database class to demonstrate queries posed in the relational algebra and to introduce the notions of integral constraints, referential integrity and functional dependencies. The system runs in either an interactive mode or interfaces with either Pascal or PL/1.
Experience with MINIX in an operating systems lab
Authors: Hartley Stephen J.
Published: July 2004

Most standard undergraduate operating systems courses teach theory and concepts, without exposing students to the detailed internal operation or source code of an actual operating system. Tanenbaum's MINIX operating system is designed to give students "hands-on" experience with the internals of an operating system in order to illustrate the theory and concepts. This paper describes the use of MINIX in an operating systems laboratory at the University of Vermont.
Academic experiences in software project management
Authors: Nute T. C. , Rienwalt J. R. , Rodjak D. J. , Golaz William H. , Comer J. R.
Published: July 2004

This paper discusses the implementation project undertaken in 1988--1989 as part of Texas Christian University's graduate program in Software Design and Development. The report summarizes the intent, schedule, man-loading, design methodologies, and development tools used during the course of the project. Included is a discussion of the project's failures and successes. The paper concludes with a discussion of the lessons that may be learned from such projects in planning future efforts of this kind.
Criteria for software reliability model comparisons
Authors: Iannino A. , Musa J. D. , Okumoto K. , Littlewood B.
Published: July 2004

A set of criteria is proposed for the comparison of software reliability models. The intention is to provide a logically organized basis for determining the superior models and for the presentation of model characteristics. It is hoped that in the future, a software manager will be able to more easily select the model most suitable for his/her requirements from among the preferred ones.
Introduction of a formal technique into a software development environment
Authors: Shaw R. C. , Hudson P. N. , Davis N. W.
Published: July 2004

This paper describes the evaluation and introduction of the Vienna Development Method (VDM) into an IDEC development project. We firstly describe why VDM was chosen and follow this with a simple VDM specification based on an Electronic Mail System. The evaluation exercise is briefly described together with the training program which was subsequently set up. Lastly we look at a language which was developed for use by the project which emcompasses both the specification style of VDM together with pseudocode and structuring mechanisms.
Implementing JSD designs in Ada: a tutorial
Authors: Yeung W. L. , Topping G.
Published: July 2004

The Jackson System Development (JSD) method is widely recognized as viable for the design of real-time embedded systems. This paper discusses the implementation of JSD designs in Ada through a simulated lift control example.
Heisenberg Uncertainty
Authors: Laplante P.
Published: July 2004

In this paper it is suggested that the Heisenberg Uncertainty Principle, normally applied to physical systems, can be applied in analogy to certain phenomena found in software engineering. The point is illustrated with several examples.The applications of this principle in the design and testing of software is discussed. The import of this is that paradigms relating physical phenomena to software engineering may be found.
Domain description grammar: application of linguistic semantics
Authors: Carasik R. P. , Johnson S. M. , Patterson D. A. , Von Glahn G. A.
Published: July 2004

Domain descriptions should represent more than the characteristics of data and the operations on it. They should be "semantic" in the sense that they may represent information such as the meanings of special terms used in the business, as well as goals and rules. ER models are often described as "semantic data models". However, the correspondence between ER and natural language is through syntactic rather than through semantic constructs. Conceptual modeling languages and knowledge representation techniques are more appropriate for representing domain meaning. Modern research in linguistics, semantics, and artificial intelligence provides valuable insight into basic issues regarding such representations. Domain descriptions must use languages based on generally-accepted linguistic and knowledge representation principles.
Biblio of object-oriented system development
Authors: Mrdalj S.
Published: July 2004

An increasing number of articles and books is being published in the area of object-oriented system development (OOSD). A need for collection, classification and evaluation of the available material is already evident. This is why we decided to collect a bibliography when we started our research project on comparison of object-oriented analysis and design methods.Most of the included items do not attack the whole problem of OOSD but together they represent work done on many aspects of the problem. Some are related to the system design using various object-oriented programming languages. Also a few items have been included that deal with object-oriented principles in general. There are even some which are "comments" or "discussions" on the topic. The items were chosen on the basis that they should have some direct reference to object-oriented system development.This bibliography contains material in the field that has been published before Spring 1990. It is by no means supposed to be complete. If any references of particular significance have been omitted, the author would appreciate hearing about them. I hope this bibliography will help those planning to build object-oriented systems, or those who are working on new OOSD methods.
Object-oriented programming in C++
Authors: Reid Richard J.
Published: July 2004

This paper describes a course that introduces students to object-oriented design, the C++ language and discreteevent simulation with animated displays. Students come to this course with a Pascal, C and Assembler background and progress through the object-oriented features of C++, completing a simulation project as a major course component. A video-tape series is used to provide C++ instruction.For the simulation project, students complete the controller portion of an elevator system involving multiple elevator cars in a multi-story building simulation. Student controllers are coupled with modules they cannot see within, but can communicate with, using the member functions provided at the object-oriented interface. The simulation and animated display give visual feedback of the performance of student control algorithms.
An NSF funded research experience for undergraduates
Authors: La Salle A. J. , Medsker L. R.
Published: July 2004

Concerns about the decline in computer science enrollments have appeared not only in computing publications but also in the mass media. Reasons for diminished interest in technology-oriented careers are many and complex. Proposed solutions for expanding the population of scientists and engineers are few and largely untested. One solution, sponsored by the National Science Foundation, is the involvement of undergraduates in a research experience with the hope that the experience will reinforce their career decision and encourage them to go on to graduate study. This paper describes an undegraduate research experience conducted at The American University, the nature of the students' involvement, and he affects of their experiences on their career goals.
A database sequence
Authors: Apenyo Kofi
Published: July 2004

A two-course upper-division undergraduate sequence in database systems offered by the computer science department at the Atlanta University Center is described. It is observed that the course contents of database program prepares students to fill the increasing number of database positions in industry while providing the broad foundation in the subject matter upon which students can build in graduate school. The program of database study consists of a core and an elective. The core covers database concepts, design, implementation, and processing. With the core as a prerequisite, the elective provides practical laboratory work that is dictated by requirements of the database industry. The database program described in this paper has been implemented at the Atlanta University Center in Atlanta, Georgia, by a JPL computer scientist with a NASA grant.
The senior seminar in computer science
Authors: Arras Richard J. , Motter Lewis
Published: July 2004

This paper considers the senior seminar course in computer science and discusses its place in preparing students for careers in computer science. It is the authors' contention that the senior seminar should attempt to prepare students for the practice of computer science in the work place. It considers the various aspects of the development and implementation of a significant user-oriented software project that serves as the cornerstone of such a course.
The arcade laboratory
Authors: Cagnat J. M. , Gueraud V. , Peyrin J. P.
Published: July 2004

We propose different ways to use the computer to help teach algorithms. Our objective however is not to develop a complete and autonomous computer assisted course, such that the student would be given a set of floppy disks and would come back a few months later only for his exams! We want rather to provid e students and teachers with software tools tha t enhance and complement teaching practices as they exist in a traditional environment: formal lectures; exercises in small groups; individual computer assignments.This paper presents elements that guided us during the elaboration of this laboratory: basic ideas, dreams and pedagogical choices. We describe the laboratory as it is today and we try to analyze its potential for students, teachers and software authors. We conclude on possible further developments.
Design and implementation of a swapper for the MINIX operating system
Authors: Chappelow Stephen W. , Ackerman Steven F. , Hartley Stephen J.
Published: July 2004

The University of Vermont does not offer a course which provides practical experience working with the internals of operating systems. To remedy this, an independent study course was undertaken during the Spring 1989 semester which involved working with the internals of a real operating system. The goal of the project was to design and implement a major component of an operating system known as the
swapper
.The basis for the project was the MINIX operating system, which is a message--passing operating system that runs on microcomputers and whose user interface mimics Version 7 UNIX
2
. The structure, algorithms, and implementation of a swapper will be analyzed in detail. Finally, the practical value of the research experience is discussed.
System construction with object-oriented pictures
Authors: Cherry George W.
Published: July 2004

This paper describes the process guide, behavior model, icons, and diagrams of SCOOP-3, a pictorial method for developing reactive systems. SCOOP-3's semantics are Concurrent C++ or Ada: its icons and diagrams are mechanically translatable to these languages. SCOOP-3's process guide supports reuse, prototyping, and concurrent specification and design. Its behavior model (S-R Machines) integrates the notions of finite and infinite automata, data abstractions, and objects. My earlier notes in SEN demonstrated the Finite State Automata power of S-R Machines. This note demonstrates their far greater power and expressiveness. SCOOP-3's black box, machine, and clear box diagrams have the same objective (and names!) as Mills' Box-Structured approach: stepwise provable specifications and designs.
Multilingual software engineering using Ada and C
Authors: Hughes David K.
Published: July 2004

The technique necessary to interface one software language with another is not clearly defined. The significant increase in the size and complexity of embedded systems and the time and cost constraints imposed by both government and the market place require that software engineers develop a better understanding of the problems of multilingual software implementation.This paper focuses on the technique necessary to successfully interface the Ada* language with the C language in homogeneous or embedded computer systems. These two languages should dominate the software development arena for at least the next decade: Ada, because it is mandated by Federal law to be used in all Department of Defense contracts which require software, and C because it is the implementation language of choice for the vast majority of commercial off-the-shelf software systems.
Time distribution analysis for binary search of a linked list
Authors: Khosraviyani Firooz , Moadab Mohammad H. , Hale Douglas F.
Published: July 2004

The aim of this article is to determine the probability distribution of sorting time for different sized linked lists utilizing binary search method and its comparison with results for sequential and binary tree search methods. In [1] the concept of binary search as applicable to linked lists has been discussed and compared with sequential search and (binary) tree search algorithms. Applying regression analysis, specific equations giving search times as a function of list size are determined. Regression analysis is also used to estimate the average performance of the
binary search method
in sorting linked lists.
Telecommunications and computer science
Authors: Jones Warren T. , McGuirt F. Mike
Published: July 2004

The purpose of this paper is to call attention to trends and curricula in the two areas of telecommunications and computer science. Telecommunications is in its infancy as an interdisciplinary academic subject which spans primarily the disciplines of electrical engineering, computer science and management. There are few telecommunications degree programs or identifiable specializations. Networks in the telecommunications industry are rapidly becoming very large distributed computing systems.In the computer industry, as well as the computer science research community, the dominant model for general purpose computing is also becoming distributed computing. However, in contrast to telecommunications, computer science is beginning to mature as an academic discipline also having interdisciplinary roots. Since many of the technologies which are critical to the successful development of the intelligent multimedia network of the future lie within the domain of computer science, there are opportunities for computer science to make a major impact on the emerging telecommunications field.
Teaching some modern functional programming concepts
Authors: Stanchev Svetlin , Radensky Atanas
Published: July 2004

In this paper a new approach to teach functional programming, based on a suitable extension of a Backus' FP-like language is presented. Our approach outperforms some others also discussed in ability concise, but not superficially to cover the whole range from very theoretic issues to very pragmatic ones.
AAPT
Authors: Sanders Ian , Gopal Harshila
Published: July 2004

Learning to program is difficult. The focus of this research was on developing an environment (AAPT) to assist the student in learning programming at an appropriate speed without a tutor having to be available. AAPT is made up of two components, a programming toolbox and an algorithm animator and is intended for use in conjunction with formal lectures, tutorials and laboratory sessions. The approach taken here is different to other work in algorithm animation because AAPT allows the student to develop the program and see how it works in the same environment.
Dynamic display of computing processes
Authors: Sigle John
Published: July 2004

Dynamic (animated) displays of computing processes such as algorithm execution seem useful in teaching computer science. Not everyone agrees with this view, however, and indeed there are some pedagogical pitfalls. This paper addresses this issue and argues that there is a proper role for such capabilities, provided that sufficient attention is given to careful reasoning about programs.
Integrating an array processor into a “hands on” computer science curriculum
Authors: Hillam Bruce P.
Published: July 2004

Problems in acquiring an array processor by a public university are discussed, including lessons learned, present uses, and future plans to develop courses in computational science.
Teaching modeling and simulation to computing science students
Authors: Cynar Sandra J.
Published: July 2004

This article discusses the contents of a course in modeling and simulation designed for Computer Engineering and Computer Science students. A discussion of the need for such a course precedes a description of the course content and assignments.
Teaching concurrent programming with Pascal-FC
Authors: Davies G. L.
Published: July 2004

This paper describes a dialect of Pascal which has been specially developed to provide students with practical experience in courses on concurrent programming. It describes the facilities of the language, and discusses the importance of the scheduler which is provided in language implementations used for teaching.
The correlation quiz
Authors: Dadamo Diana T.
Published: July 2004

In order to develop programming ability, computer science courses typically include a number of out-of-class assignments. To motivate the students in completing these assignments, these projects are usually graded and the values included in the computation of the final grade for the course. However, the amount of cheating done on the programming assignments makes it unfair to heavily weigh these values. Some systems of grading have been developed that downplay the effect of the programming assignment grades but this negates the effort of the students and the importance of developing the practical aspects of a programming language. Within the constraints of an out-of-class programming assignment, this paper proposes a new system that can potentially reduce the incidence of cheating while requiring honest students to review their program after completion. (The development of the
Correlation quiz
was done while the author was a Senior Lecturer at Widener University.)
EASY/VI—a new instructional computer
Authors: Koneva Luisa , Denev Jordan
Published: July 2004

In this paper it is suggested a simple hypothetical computer which has been designed to assist teaching of the basic concepts in introductory course in computer organization and assembly language programming. The hypothetical computer and the instructional assembly language presented here have some new features which facilitate learning significantly. They have been designed to be a vehicle in almost all the lectures of the course.
The four-peg Tower of Hanoi puzzle
Authors: Chu I-Ping , Johnsonbaugh Richard
Published: July 2004

We discuss a version of the Tower of Hanoi puzzle in which there are four pegs rather than three. The fourpeg puzzle provides a rich source of exercises (samples of which are included) for students after the familiar three-peg version has been presented. We give an algorithm that solves the four-peg puzzle in the claimed minimum number of moves (see [2, 4]). Our algorithm solves the four-peg puzzle in
O
-(4
√n
) moves whereas the best algorithm for the three-peg puzzle requires 2

n

- 1 moves. As far as we know, the minimum number of moves required to solve the four-peg puzzle is an open question.
Fun, rigour and pragmatism in functional programming
Authors: Sánchez-Calle Angel , Velázquez-Iturbide J. Angel
Published: July 2004

A course on functional programming using Hope is presented. It describes the basic principles of functional programming, the syntax and semantics of Hope, and some techniques for the analysis and design of programs. A main feature of the course is the integration in a natural way of formal methods and reusability with programming.
WHILE loops and the analogy of the single stroke engine
Authors: Cole Jerald D.
Published: July 2004

Researchers have found that loop constructs, such as the WHILE (top tested) and REPEAT-UNTIL (bottom tested) in modern programming languages are problematic for a significant number of novice programming students[5]. In theory, any bottom tested loop can be implemented as a top tested loop. Unfortunately, the converse of this is not true, leading to some of the confusions experienced by beginners. To circumvent this and other problems, Taylor[7] advocates postponing the introduction of the REPEAT-UNTIL. Instead, he discriminates between two fundamental types of WHILE loops, designated the SENTINEL WHILE and the COUNTER WHILE, which are sufficient for the implementation of any loop. A key element of Taylor's pedagogical approach is the introduction of these concepts in the context of analogies. This approach is utilized in the exposition that follows.
ALEX: an aid to teaching algorithms
Authors: Pyott Sean , Sanders Ian
Published: July 2004

A problem with teaching Computer Science to first-year students in a South African context is that many students come from disadvantaged backgrounds and have not been exposed to computer technology. To address this issue, a new curriculum has been adopted for first-year students, the first topic of which covers the design and specification of algorithms. One of the problems encountered in this course is that if the students cannot execute their algorithms they do not know whether the algorithms are correct. One approach to this problem is to require that students be familiar with a programming language. This paper investigates an alternative way of executing algorithms, the ALEX system, and discusses how the system can be used to assist in the teaching of algorithms.ALEX allows students to specify algorithms in an English-like manner and translates these algorithms into an equivalent executable high-level language code, which is then executed. Based on the evaluation of individual students, the use of ALEX is beneficial. However, further experimentation has to occur before the effectiveness of using ALEX can be properly assessed.
Code reader
Authors: Kamat Vikas K.
Published: July 2004

Source code reading as an element of Software Engineering has long been ignored. Presented here is a pseudo-design of a Code reader (CREAD) for 'C' like language.
Making software reuse work: an implementation model
Authors: Prieto-Díaz Rubén
Published: July 2004

Despite software reuse's promise to significantly improve software quality and productivity, its practice remains elusive. The difficult issues outside the technical realm are seldom addressed. To be practical, reuse must address not only technical but managerial, economic, performance, cultural, and technology transfer issues. A model for implementing software reuse programs is discussed and supported by successful experiences. This model is based on an incremental strategy and addresses the above issues, directly and indirectly. The approach is practical, effective, and has potential to make reuse a regular practice in the software development process. Portions of the model have been used successfully in consulting with SPC member companies.
Systems deployment planning and scheduling
Authors: Saradhi Motamarri
Published: July 2004

In any large scale Systems Development activity, it is unlikely that the whole application system is ready at a time for deployment/launching to live action. In case of turnkey projects the situation is much more critical. Added to this there can be situations in which, the implementation of design and deployment of application system may have to go in tandem. As the Systems Development Life Cycle does not include these, the Project Management within that constrained framework may likely face enormous setbacks. I have realised these issues in the process of a turnkey computerisation project for a large Thrift and Credit Co-Operative Society application. The paper aims at elaborating the role of Systems Deployment Planning and Scheduling for successful Systems Development and Deployment in such situations.
Quality assurance through direct implementation of analysis and design constructs
Authors: Smith Richard E.
Published: July 2004

A measurably good design does not guarantee a correspondingly good implementation. When an implementer translates a software design into the implementation language. We weaken the correspondence between the measured capabilities of the design and the implementation. This can lead to a failure to achieve goals that the design originally assured. We can avoid such failures if we transform the exad models and structures from the analysis and design phase into software components of the implementation.This paper presents a practitioners efforts to integrate realtime software implementation with the abstractons used in system analysis and design. Our approach as been to adapt existing paradigms and took to achieve this effect. We have applied this to three real time software projects using techniques such as object oriented analysis and data low design.
Approach to a disciplined development process - the ISTAR integrated project support environment
Authors: Lehman M
Published: July 2004

This paper is an extended, written, version of a presentation to the Second Process Workshop. It presents a systematic, top down, approach to the design of integrated project and programming support environments (IPSEs) using the ISTAR project at Imperial Software Technology Ltd as an illustration. In the context of the Workshop the talk was intended to describe an approach to software development and evolution in general. If that be his concern the reader may so interpret the text. Alternatively it may be seen as an introduction to ISTAR and a contribution to IPSE development technology.
ESA—an expert supported OOA method and tool
Authors: Schaschinger Harald
Published: July 2004

Although this paper deals with object-oriented software development in general, the focus is definitely set on object-oriented analysis (OOA). After a short comparison of the most important OOA approaches, a new one will be derived. This approach is evolutionary, non-domain specific and starts at the definition of a software system. Based on this approach there will be a presentation of an
e
xpert
s
upported OO
A
tool (
ESA
), which supports an analyst starting at the collection of the requirements through the analysis of an object-oriented system up to a preliminary high-level design. Both the method and the tool are conceived for the needs of practitioners.
Systems modelling and description
Authors: Saradhi Motamarri
Published: July 2004

The purpose of this paper is to enunciate the underlying notions of
systems modelling
. There is an obvious lack with many techniques to allow the description of the real world as native to its functioning as possible. A generic analytical framework is likely to have a strong impact in problem solving, whatever may be the domain. Further, it may ease the process of communication among various people by virtue of proper capturing of the system functionality in a more understandable framework. The exploration for such a framework will also rationalize the development process of computerized systems, whether they are going to employ conventional software or AI/ES techniques. The criticality of the computerized systems has been raising potential problems with respect to safety and security. Validation and verification of the systems have become a potential challenge. The current discussion will shed light on these issues, and guide in ensuring a robust application system.
Some notes on software design
Authors: McLaughlin Robert
Published: July 2004

Mr. van Reeken wrote a note on my note. It is nice to know that some reads what you write. I think his comments force me to be a little more specific. I agree with some of what he says, but must mark my disagreement with other things he says.
Redesign of an A.S. degree in computer science to meet emerging national standards
Authors: Harris William C. , Johnson Leon P.
Published: July 2004

The state of science and technical education is at a crucial juncture in our nation. In order to address this issue, the Division of Natural Sciences and Mathematics felt the need to incorporate recent technological developments into its Computer Science program. A conceptual framework for the revision and the resulting A.S. degree in Computer Science Program with a Telecommunications option are presented.
Translation—an introductory exercise
Authors: Piotrowski Jerzy A.
Published: July 2004

The paper presents a case for using the functional language Miranda
†
as a tool in building simple models used in undergraduate Computer Science and Computer Engineering classes. Lexical analysis, parsing and generation of code are described by functions. However, only parsing is presented here with some detail, while two other phases are outlined. Some laboratory experiments suggested for students are also included.
Hypercard automata simulation
Authors: Hannay David G.
Published: July 2004

This paper describes a package of highly interactive simulation models for the concepts taught in Theory of Computing courses. Macintosh Hypercard stacks are used to demonstrate the three basic automata models: Finite-State Machines, Push-Down Machines, and Turing Machines. These simulations feature multiple named machines on the same stack, accessible via a customized menu or buttons on the screen. Because of the scripts hidden behind the visible screen, with just a click of a butto students can alter starting states, the set of input symbols, the number of states, the finality of states, or the action based on a given state/input combination. These simulations have been successfully used in conjunction with a course on the Theory of Computing at Union College since 1989. Students have responded enthusiastically to this concrete method of teaching abstract concepts.
Computer science in an undergraduate liberal arts and sciences setting
Authors: Prather Ronald E.
Published: July 2004

In this article, we intend to establish a collegial meeting ground among faculty and administrators for a broad discussion of the role of computer science in an undergraduate liberal arts and sciences university. And both groups are in mind as the potential audience. As our title suggests, we are specifically excluding from consideration those schools having significant graduate degree programs, though some of our observations may be appropriate there as well. And we are thinking primarily of the high-quality liberal arts and sciences institutions, or at least of those who aspire to be so designated, where a primary emphasis is placed on preparing students for graduate work at the major universities.In this restricted setting, questions arise for administrators that transcend the narrow parochial characterizations of the field of computer science, those framed by its practitioners and generally recognized authorities (usually found at the larger research universities). How well does computer science fit with the classical liberal arts and sciences tradition, and with the "mission" as a whole? Do we already have enough "computer expertise" around the campus, without initiating or maintaining a separate department? Can we afford it? Is it time to dismantle it or merge it with another department? Otherwise, is it in need of serious revision? One may judge from this line of questioning that we intend to give an equal consideration to those computer science programs that are "starting up" and those that are thinking about "starting over."
Cataloguing and classification for object libraries
Authors: Henderson-Sellers B. , Freeman C.
Published: July 2004

Reusable object classes are seen as a major benefit of adopting the object-oriented paradigm in the commercial data processing and applications programming worlds. However, without some efficient and effective method of locating previously written classes, this benefit of reuse will be lost. Code location requires the classes to be stored in some retrievable fashion. Such an underlying classification system, together with an associated cataloguing system, appropriate for object libraries, is proposed.
A balanced approach to first-year computer science
Authors: Kay David G.
Published: July 2004

We describe a first-year course sequence for computer science majors that covers most of the traditional first-year concepts, providing a balance between formal analysis and software synthesis, with examples and assignments in three high-level programming languages: Pascal, Scheme (a lexically scoped dialect of Lisp), and C. We argue that this balanced, tri-lingual approach promotes more effective pedagogy and provides students with a broader foundation than does an all-formal, all-programming, or single-language focus.
The practical need for fourth normal form
Authors: Wu Margaret S.
Published: July 2004

Many practitioners and academicians believe that data violating fourth normal form is rarely encountered. We report upon a study of forty organizational databases; nine of them contained data violating fourth normal form. Consequently, the need to understand and user fourth normal form is more important than previously believed.
The documentation and evaluation of team-oriented database projects
Authors: Pigford D. V.
Published: July 2004

This paper focuses on documentation and evaluation techniques for monitoring and assessing team oriented database projects in a senior level database course in computer science. Instead of effecting documentation as the last phase in traditional software development, the documentation procedures are implemented as nine separate staggered deliverables during the project development. These deliverables are revised and organized into a final documentation binder. Evaluation techniques are monitored through four distinct phases: Project Plan, Ongoing Documentation, Progress Report, and Project Presentation (Demonstration).
Men supporting women computer science students
Authors: Myers J. Paul
Published: July 2004

It has become clear that, for a variety of reasons, women CS enrollments are declining at a disproportionate rate and that the number of women “in the pipeline” is insufficient to mentor and otherwise support the development of CS interests among current young women in the field. Recommendations have been made for male assistance in this mentoring effort; and some ideas toward this end are presented here. Regrettably, in this context, it is necessary to head off charges of “patronizing” our women students lest the ideas be disregarded or trivialized.
A seminar course in object oriented programming
Authors: Bellin David
Published: July 2004

The emerging technology of object oriented programming is just beginning to be introduced into the computer science curriculum. In most schools, it will be introduced first at the more advanced levels, prior to inclusion in introductory courses, even though the object oriented paradigm may be more suitable for teaching basic computer science concepts.

This paper contains the experiences gained teaching a seminar on object oriented programming to a small group of mixed graduate and undergraduate students at a school with no doctoral program. The successes and difficulties faced by both students and instructor are explored.