bluuebunny/crossref_metadata_2025_split huggingface dataset:
Requirements-based monitors for real-time systems
Authors: Peters Dennis K. , Parnas David L. 
Published: July 2004

Before designing safety- or mission-critical real-time systems, a specification of the required behaviour of the system should be produced and reviewed by domain experts. After the system has been implemented, it should be thoroughly tested to ensure that it behaves correctly. This is best done using a monitor, a system that observes the behaviour of a target system and reports if that behaviour is consistent with the requirements. Such a monitor can be used both as an oracle during testing and as a supervisor during operation. Monitors should be based on the documented requirements of the system.
If the target system is required to monitor or control real-valued quantities, then the requirements, which are expressed in terms of the monitored and controlled quantities, will allow a range of behaviours to account for errors and imprecision in observation and control of these quantities. Even if the controlled variables are discrete valued, the requirements must specify the timing tolerance. Because of the limitations of the devices used by the monitor to observe the environmental quantities, there is unavoidable potential for false reports, both negative and positive.
This paper discusses design of monitors for real-time systems, and examines the conditions under which a monitor will produce false reports. We describe the conclusions that can be drawn when using a monitor to observe system behaviour.
Model checking Java programs (abstract only)
Authors: Dill David 
Published: July 2004

Automatic state exploration tools (model checkers) have had some success when applied to protocols and hardware designs, but there are fewer success stories about software. This is unfortunate, since the software problem is worsening even faster than the hardware and protocol problems. Model checking of concurrent programs is especially interesting, because they are notoriously difficult to test, analyze, and debug by other methods.
This talk will be a description of our initial efforts to check Java programs using a model checker. The model checker supports dynamic allocation, thread creation, and recursive procedures (features that are not necessary for hardware verification), and has some special optimizations and checks tailored to multi-threaded Java program. I will also discuss some of the challenges for future efforts in this area.
Cascaded refactoring for framework
Authors: Butler Greg , Xu Lugang 
Published: July 2004

Refactoring of source code has been studied as a preliminary step in the evolution of object-oriented software. We extend the concept of refactoring to the whole range of models used to describe a framework in our methodology: feature model, use case model, architecture, design, and code. We view framework evolution as a two-step process: refactoring and extension. The refactoring step is a set of refactorings, one for each model, that cascades through them. The refactorings chosen for a model become the rationale or constraints for the choice of refactorings of the next model.
The cascading of refactorings is aided by the alignment of the models. Alignment is a traceable mapping between models that preserves the commonality-variability aspects of the models.
A tool designed to facilitate structured programming
Authors: Hughes Herman D. 
Published: July 2004

An algorithmic language interpreter is presented which provides users of various technical backgrounds a convenient way to describe algorithms and simultaneously focus on problem-solving concepts: problem analysis, algorithm development, and the computer implementation of the algorithm. The interpreter permits the use of decision tables as a means of expressing complex logic.
In view of the significance of structured programming in today's environment (and that of the future), the language processor allows three logical constructs: sequential, IF... THEN...ELSE..., and the DO WHILE construct. The use of GO TOs is only allowed to transfer control from one table to another. Hence, several tables/subtables (each may contain 1 decision table) may be required for the description of an algorithm. Examples are presented to illustrate how the language interpreter enhances programming organization and thereby facilitates structured programming.
Practical experience in top-down structured software production in an academic setting
Authors: Tam W. C. , Busenberg S. N. 
Published: July 2004

Much has been said about the importance of teaching top-down program design and structured programming in computer programming courses. However, instruction in these concepts has usually been limited to short homework assignments and at most to term projects. This type of experience is very different from the production programming environment encountered in industry, where the problems tackled are generally more complex and on a larger scale. Also, in many cases industrial programs are produced by a programming team under constraints in both time and resources. For students who aspire to a career in the software area, experience in a realistic production programming environment is desirable. Such experience is not provided in the traditional courses and novel ways have to be devised in order to bring it on campus.
At Harvey Mudd College, an academic program, called the Mathematics Clinic, has been institured with the aim of providing this type of realistic experience to the student. The Mathematics Clinic brings problems from industry to be studied and solved by small teams of students under faculty supervision. The problems are selected for their educational value, but attention is paid to the feasibility of producing results that are of value to the sponsoring industrial concern.
The general organization of the Clinic program has been described by Spanier (1). In the present paper, a production programming project undertaken by the Mathematics Clinic is described with emphasis placed on the mode of instruction and the experience gained by the students.
An experience in teaching “cobol?” to graduate engineers
Authors: Bremmer Dale , Childs Bart 
Published: July 2004

Texas A&M University was involved for ten years in a program to train civilian engineers for the US Army. The engineer, the program's product, was to be capable of moving into positions of management and middle management within the civilian employment force of the Army. Most of the participants held various undergraduate degrees in engineering, science, or mathematics, and a few held degrees in technology or business. The structure and tenure of the program made it feasible for the participants to earn a Master's degree in Industrial Engineering.
Once on the job, many of the engineers found they were faced with large data file manipulation and information retrieval tasks. To many, this meant time consuming efforts and often additional training or help from other departments.
The authors believe that some of the engineer's job frustrations were inherent in the manner in which the computer's growth and application has influenced the pedagogy of computer courses related to engineering curricula. The authors also believe they have found one solution to the problem within the confines of the above mentioned Army civilian engineer training program.
A place for assembler in structured programming
Authors: Beidler John 
Published: July 2004

Today, with the thrust being made with structured programming, questions arise concerning the relevance of assembler language code. The purpose of this paper is to defend assembler language programming by showing its relevance and to show how we present the course with a structured programming emphasis.
In the sections that follows, we show the relevance of assembler through two examples of the use of assembler language coding. These examples show two extremes, one involves the development of a theoretical result in mathematics, the other shows the use of assembler in a commercial environment.
Section 3 provides an overview to our approach in the course and how we view the role of assemblers in structured programming. Section 4 illustrates our approach to programming assignments and section 5 describes our approach to evaluating assignments.
First course in computer science, a small survey
Authors: Furugori T. , Jalics P. 
Published: July 2004

In many disciplines, the introductory courses are well standardized as to what should be covered, how the subject is to be taught, and how student's performance is to be measured. Such is certainly not the case in Computer Science, where we constantly debate what should be taught, what programming language is to be used, the nature of assignments to be given, etc.
We wanted to see how other schools were teaching this first course, so we sent questionnaires to all the Universities listed in the ACM Graduate Assistantship Directory. From the 44 schools responding to the survey, we want to share some interesting facts concerning the manner in which Computer Science is taught.
The teaching of program correctness
Authors: Maurer W. D. 
Published: July 2004

For the past seven years, including three years at the University of California (Berkeley) and four years at The George Washington University, this author has taught material relating to the correctness of programs in both undergraduate and graduate courses.
The simplest material on correctness that we teach is the proof of correctness of Euclid's algorithm, implemented as a program in FORTRAN, AL-GOL 60, PL/I, or BASIC, depending on the language to which elementary students are first introduced. (It would work just as easily in PASCAL.) This proof is found in (1), pp. 14-20. We usually give a simplified version of it, because the program in (1), for purposes of efficiency, works by dividing and taking the remainder, and we feel it is easier to illustrate the relevant concepts by using an algorithm that works by simple subtractions.
The Poe language-based editor project
Authors: Fischer C. N. , Johnson Gregory F. , Mauney Jon , Pal Anil , Stock Daniel L. 
Published: July 2004

Editor Allan Poe (Pascal Oriented Editor) is a full-screen language-based editor (LBE) that knows the syntactic and semantic rules of Pascal. It is the first step in development of a comprehensive Pascal program development environment.
Poe's design began in 1979; version 1 is currently operational on Vax 11s under Berkeley Unix and on HP 9800-series personal workstations. Poe is written in Pascal, and is designed to be readily transportable to new machines. An editor-generating system called Poegen is operational, and much of the language-specific character of Poe is table-driven and retargetable.
The Darwin software-evolution environment
Authors: Minsky N. , Borgida A. 
Published: July 2004

The main goal of the Darwin software development environment is to establish a rigorous authorization-based discipline which can be used to impose constraints on the structure and operations of software systems as well as on their process of development Such constraints might be desirable to serve the following needs:
• The need to provide support and enforcement for such software engineering techniques as informationhiding, data abstraction and modularization, even when these techniques are not offered by the programming language itself.
•The need to support rules which govern the real enterprise being served by the system, and which must be invariant of the evolutionary behaviou of the system.
• The need to enforce managerial policies concerning the process of system development itself.
Preliminary experience from the dice system a distributed incremantal compiling environment
Authors: Fritzson Peter 
Published: July 2004

Abstracts The DICE system Is a highly Integrated programming environment which provides programmer support in the case where the programming environment resides in a host computer and the program Is running on a target computer that Is connected to the host. Such a system configuration is also suitable for remote debugging and maintenance of production versions of programs that has been installed in a user environment.
The system contains tools such as an screen-oriented structure editor, a statement-level incremental compiler, a screen-oriented debugger and a program database. The debugger uses the same facility for pointing and display as does the editor, and it uses the incremental compiler for insertion of breakpoints and statement evaluation. Most of these tools are automatically generated from compact descriptions.
This paper describes some aspects of a prototype version of the system and gives some preliminary data on the performance. Also, strategies for implementing portable programming environments are discussed and are exemplified by the DiCE system.
Early experience with Mesa
Authors: Geschke Charles M. , Morris James H. , Satterthwaite Edwin H. 
Published: July 2004

The experiences of Mesa's first users—primarily its implementers—are discussed, and some implications for Mesa and similar programming languages are suggested. The specific topics addressed are:
module structure and its use in defining abstractions,
data-structuring facilities in Mesa,
equivalence algorithm for types and type coercions,
benefits of the type system and why it is breached occasionally,
difficulty of making the treatment of variant records safe.
Formal foundations of software evolution
Authors: Mens Tom , Wermelinger Michel 
Published: July 2004

The workshop on
Formal Foundations of Software Evolution
was co-located with the
5th European Conference on Software Maintenance and Reengineering
(CSMR 2001), which took place at the Centro de Congressos do Instituto Superior Tcnico in Lisbon, Portugal, March 14 to 16, 2001. The workshop was organised in the context of the
Scientific Research Network on Foundations of Software Evolution.
This is a research consortium coordinated by the Programming Technology Lab of the Vrije Universiteit Brussel (Belgium), and it involves 9 research institutes from universities in 5 different European countries (Belgium, Germany, Austria, Switzerland, and Portugal). The consortium is financed by the Fund for Scientific Research - Flanders (Belgium).One full day was allocated for the workshop (March 13, 2001). There were 14 participants, that all contributed with a position paper which was reviewed and revised before the workshop. Next to the submissions of the research consortium partners, there were also participants from research institutes in Spain, United Kingdom, Finland, and Japan. In preparation to the workshop, participants were requested to read all other submissions, and asked to prepare a clear position statement and questions that were likely to stimulate discussion.The goal of the workshop was to get more insight into how formal techniques can alleviate software evolution problems, and how they can lead to tools for the evolution of large and complex software systems that are more robust and more widely applicable without sacrificing efficiency. Preferably, the evolution-support tools should not be restricted to a particular phase of software evolution [BR00], but should be generally applicable throughout the entire application lifetime. The tools should also provide support for different aspects of software engineering, such as forward engineering, reverse engineering, re-engineering, and team engineering.In order to stimulate discussions, three general important questions were posed to the participants at the beginning of the workshop:

Which aspects of software evolution need to be automated by tools?

Where and how can formalisms help us to achieve tool support?

How can we build formally-founded tools that are as general and flexible as possible? Note that the generality and flexibility of a tool involves many different aspects:

--- independence of the programming language for which support should be provided;
--- customisability by the user of the tool;--- applicability in or across different stages of software evolution;
--- interoperability with other tools;
--- scalability to large and complex software systems with multiple developers;
--- usable for static (design-time) as well as dynamic (runtime) evolution;
--- applicable to forward, reverse, and re-engineering;
--- usable before, during, and after evolution;
--- usable for facilitating, supporting, as well as analysing evolution;

--- to deal with the
what and why
as well as the
how
of software evolution
Development and documentation of computer programs in undergraduate computer science programs
Authors: Deneen Linda L. , Pierce Keith R. 
Published: July 2004

Until recently, introductory programming classes in the Department of Computer Science, University of Minnesota, Duluth, concentrated on writing code. Not until the junior or senior year were students required to adhere to basic principles of software engineering. As might be expected, by their junior year students' bad habits, like coding while designing or inserting comments last, were firmly entrenched and difficult, if not impossible, to undo.
The solution, it seemed to us, was to prevent bad habits right from the start. Consequently, we developed guidelines for designing and documenting the entire programming effort, from problem statement to post mortem. The guidelines include such steps as: algorithm development in high-level pseudocode with stepwise refinements, structure diagrams with data flow, detailed test descriptions, testing results, and a description of all known bugs. For a given assignment, the instructor chooses the steps to be completed, allowing for flexibility and appropriateness in the design and documentation.
Results have been extremely positive. Students start earlier and produce better organized solutions. More students solve the problems correctly. Most importantly, students develop design and documentation skills in the freshman year that carry through and are improved over their four-year stay. Because of this initial success, our department has adopted these guidelines uniformly in all programming classes.
In this paper we will describe our guidelines and give some details of their use. We will discuss the philosophy that led us to develop these guidelines and present our observations of their effectiveness.
An introduction to the parallel distributed processing model of cognition and some examples of how it is changing the teaching of artificial intelligence
Authors: Whitson George M. 
Published: July 2004

Artificial Intelligence programming involves representing knowledge, using paradigms to manipulate the knowledge, and having a learning process modify both the knowledge and the paradigms. One could consider this process as building a model of how one thinks, i.e. how the brain operates at the cognitive psychology level [2]. Recently, cognitive scientists have developed a model of how one thinks at the neural level. This model is called the Parallel Distributed Processing (PDP) model of cognition and is described in the definitive work of Rumelhart and McClelland [1]. The idea that we can actually model the brain as an electrical network of neurons and then develop Artificial Intelligence in terms of the model is extremely attractive. The program has had some success, especially in the area of sensory perception and motor activity, but still has some problems to overcome before it can be said to be the ideal foundation for Artificial Intelligence.
Much of the power of the PDP model derives from the learning algorithms. In this paper we consider a classification of learning algorithms that helps to organize the many developing techniques seen in the literature. We also discuss how the PDP model is changing the way we teach Artificial Intelligence. This is an important aspect of the PDP model, since the model has produced a number of new problem-solving techniques for Artificial Intelligence as well as holding out the promise of a better foundation for the basic theory of this field. If the PDP model fulfills its promise we would develop Artificial Intelligence programs that are really intelligent rather than programs that only appear to be intelligent.
Introducing knowledge-based projects in a systems development course
Authors: Kanabar Vijay 
Published: July 2004

Due to recent advances in knowledge-based systems technology it is suggested that students in a systems development course be given exposure to the concept of designing and implementing knowledge-based systems.
The purpose of this paper is to describe the objective, scope, methods and procedures of knowledge-based projects. The first half of the paper introduces the knowledge-based approach and describes the structure and components of such a system. The second half of the paper deals with course design procedures. The scope, topics, project characteristics and experiences pertaining to such a project are covered here.
A practical Knowledge-based Systems Development Life Cycle (KSDLC) is also proposed for use in such a course. It is a suitable methodology as it resembles the traditional Systems Development Life Cycle.
A microcomputer oriented computer literacy course
Authors: Clarke Alice L. , Adkins Gerald W. 
Published: July 2004

The development of a computer literacy course at the University of Georgia is described. Demographic information regarding students taking the class is provided. The course consists of two main parts:
1) microcomputer lab sessions devoted to working with word processing, spreadsheet, and data base software and to programming in BASIC; and
2) readings in a course text and viewing of telecourse tapes.
Course content and testing procedures are described in detail. How the course is changing with time and experience is also discussed.
Extended programming in the large in a software development environment
Authors: Lewerentz Claus 
Published: July 2004

This paper deals with the programming in the large part and the integration with related activities (programming in the small, variant control, support of technical documentation, responsibility and access control) of the software development and maintenance process. It is pointed out how these tasks are supported with an integrated and incremental software project support environment (IPSEN).
Snapshots of a working session are used to demonstrate the user interface and the functionality of the tools for the above mentioned topics. The main concern of this paper is to show how an incremental and integrated tool set, regarding the consistency of software documents can support software development.
A unifying model for consistent distributed software development environments
Authors: Walpole J. , Blair G. S. , Malik J. , Nicol J. R. 
Published: July 2004

The increase in size and complexity of software projects over recent years has lead to the need for Software Development Environments (SDEs). SDEs are intended to provide assistance in the development of large software systems involving teams of people. It is generally agreed that SDE's should be built on a distributed base. However, the distribution of computer systems introduces several problems which make it very difficult to maintain the
consistency
of data.

To ensure that changes to data are made consistently the concept of atomic transactions is usually adopted. However, existing transaction mechanisms are unsuitable for use in a distributed SDE. Furthermore, transactions are not the only mechanism concerned with controlling changes to the SDE database. The control of change is also a task for version and configuration control mechanisms. Traditionally, the functions of version control, configuration control and transactions have been treated as separate, unrelated issues.
This paper presents a new model which unifies all three concepts in a distributed SDE. Mechanisms for supporting the new model are presented and the application of the model to the Cosmos Distributed SDE is discussed.