bluuebunny/crossref_metadata_2025 huggingface dataset:
Consistency in software system development
Authors: Hangensen Torben Mejlvang , Kristensen Bent Bruun
Published: July 2004

An important aspect in the software development process is the consistency between various parts of the software system being designed and implemented. During the development of a system we are aware of the consistency problems and we usually solve these by special arrangements developed as part of the development of the software system. In general the solutions applied for some specific system cannot be reused for other systems.

The purpose of this paper is to introduce a general understanding of consistency and the techniques and tools for handling consistency. We introduce a concept called description to denote the various pieces of information which must be consistent. The description covers any fragments software and data, e.g. such as source code, parse trees, and machine code. The interpretation of a description is defined as a mapping into the set of objects, that the description is supposed to describe. Consistency of descriptions is defined as relations between the interpretations of the descriptions. The concepts description, interpretation and relation are used as a framework for modeling consistency in software systems. A consistency model includes interfaces, control parts and representions for descriptions in a system, and a specification of the consistency relations, that are relevant for the system.

The model provides consistency as a new and very important perspective on software systems. It provides a graphical notation, which gives an overview of the consistency relations in a software system being designed. The model is very general and it does therefore apply to any type of software systems. This restricts the level of detail in the model of consistency, but the model allows enhancement of the specification once the type of software system is given.

We define four basic techniques for handling consistency in software systems modeled in terms of descriptions. By combining these techniques we are able to describe the handling of consistency in a given software system. These techniques and the graphical consistency modeling language form a first step towards an engineered approach to the construction of software systems from a consistency view.
A transformational approach to generating application-specific environments
Authors: Garlan David , Cai Linxi , Nord Robert L.
Published: July 2004

Current software development environments tend to lie at opposite ends of a spectrum: at one extreme are specialized application generators; at the other are general-purpose programming environments. The former provide strong support for system development and reuse, but are costly to build and available only for limited domains. The latter provide weak support, but are generally available and universally applicable.

We describe a technique for automating the production of application-specific environments that lie between these two extremes. The key idea is that these environments can be derived from general-purpose programming environments by a process of structured transformation. We describe a tool for performing these transformations. It provides a set of formal operators for specializing a description of a general-purpose environment; as operators are applied, the system semi-automatically builds a set of transformation rules used to translate application-specific programs into those of the original general-purpose environment. The output of the tool is an application-specific environment together with a program transformer that provides execution semantics for programs written in that environment.
A reverse engineering environment based on spatial and visual software interconnection models
Authors: Müller H. A. , Tilley S. R. , Orgun M. A. , Corrie B. D. , Madhavji N. H.
Published: July 2004

Reverse engineering is the process of extracting system abstractions and design information out of existing software systems. This information can then be used for subsequent development, maintenance, re-engineering, or reuse purposes. This process involves the identification of software artifacts in a particular subject system, and the aggregation of these artifacts to form more abstract system representations. This paper describes a reverse engineering environment which uses the
spatial
and
visual
information inherent in graphical representations of software systems to form the basis of a software interconnection model. This information is displayed and manipulated by the reverse engineer using an interactive graph editor to build subsystem structures out of software building blocks. The spatial component constitutes information about how a software structure looks. The coexistence of these two representations is critical to the comprehensive appreciation of the generated data, and greatly benefits subsequent analysis, processing, and decision-making.
Integrating the heterogeneous control properties of software modules
Authors: White Elizabeth L. , Purtilo James M.
Published: July 2004

A concurrent software application, whether running on a single machine or distributed across multiple machines, is composed of tasks that interact (communicate and sychronize) in order to achieve some goal. Developing such concurrent programs so they cooperate effectively is a complex task, requiring that progrmmers craft their modules–the components from which concurrent applications are built—to meet both functional requirements and communication requirements. Unfortunately the result of this effort is a module that is difficult to reason about and even more difficult to reuse. Making programmers treat too many diverse issues simultaneously leads to increased development costs and opportunities for error. This suggests the need for ways that a developer may specify control requirements separately from the implementation of functional requirements, but then have this information used automatically when building the component executables. The result is an environment where programmers have increased flexibility in composing software modules into concurrent applications, and in reusing those same modules. This paper describes our research toward a technology for control integration, where we have developed techniques for users to express control objectives for an application and a system that translates those specifications for use in packaging executables.
An analysis technique for examining integration in a project support environment
Authors: Brown Alan W. , Feiler Peter H.
Published: July 2004

While many Computer-Aided Software Engineering (CASE) tool vendors claim to provide open, integrated environments for software development, in practice such claims must be examined very carefully to understand what is meant. One of the problems faced in trying to examine these claims is that there is no established technique for examining software development environments with regard to their integration characteristics.
An architecture for multi-user software development environments
Authors: Ben-Shaul Israel Z. , Kaiser Gail E. , Heineman George T.
Published: July 2004

We present an architecture for multi-user software development environments, covering general, process-centered and rule-based MUSDEs. Our architecture is founded on componentization, with particular concern for the capability to replace the synchronization component–to allow experimentation with novel concurrency control mechanisms–with minimal effects on other components while still suporting integration. The architecture has been implemented for the MARVEL SDE.
The ProcessWall
Authors: Heimbigner Dennis
Published: July 2004

The ProcessWall is a process state server providing storage for process states plus operations for defining and manipulating the structure of those states. It separates the state of a software process from any program for constructing that state. Instead, client programs implement the processes for operating on the process state. This approach has a number of potential benefits such as support for process formalism interoperability, support for multiple process languages, low-cost retro-fitting of process into existing environments, and support for long-term execution of processes. The process server interface provides descriptive mechanisms for representing process state as well as product state. A classification of client programs is provided to show how the state server can be used in a variety of ways.
Issues encountered in building a flexible software development environment
Authors: Kadia R.
Published: July 2004

This paper presents some of the more significant technical lessons that the Arcadia project has learned about developing effective software development environments. The principal components of the Arcadia-1 architecture are capabilities for process definition and execution, object management, user interface development and management, measurement and evaluation, language processing, and analysis and testing. In simultaneously and cooperatively developing solutions in these areas we learned several key lessons. Among them: the need to combine and apply heterogenous componentry, multiple techniques for developing components, the pervasive need for rich type models, the need for supporting dynamism (and at what granularity), the role and value of concurrency, and the role and various forms of event-based control integration mechanisms. These lessons are explored in the paper.
Software engineering in commercial programming courses
Authors: Adigum M O
Published: July 2004

The theory and practice of Software Engineering is introduced to undergraduate computer science students in their third year at the University of Ife. It is taught as part of two Commercial Programming courses, one in the first semester and the other in the second semester. This paper discusses the modus operandi of this exercise and outlines the topics covered in the instruction.
An Ada course for upper-level undergraduates
Authors: Temte Mark
Published: July 2004

As the Ada programming language becomes established, it will have an impact on computer education. In the short term, there will be a need to provide Ada exposure to mature upper-level undergraduates who are already skilled in other languages. Although language proficiency is important, this exposure should not focus on language features but rather on the support Ada provides to modern software engineering practice. The content of a course providing such an exposure is described together with a pedagogical approach that proved to be quite successful.
The computational view of nature: A liberal arts course in computer science
Authors: Ourusoff Nicholas
Published: July 2004

A liberal arts course in computer science should convey a computational view of nature. This is best achieved by focusing on a few ideas.
A transformation-access model for program visualization action-on-data displays
Authors: Ezell Cloyd L
Published: July 2004

Program visualization deals with the problem of showing the execution of a computer program. In this paper, program visualization is seen to also involve questions of how we conceptually view a program. One such view, namely viewing a program in terms of its action on its data structures, is investigated and a formal mathematical model for this view is presented. Examples are given to illustrate situations where this view is useful and where not so useful.
Compiler construction: a course outline and project description
Authors: Milito Elaine R , Traub Marsha L
Published: July 2004

A course in compiler construction will allow students to examine how a high-level language program is accepted as input and translated into assembly language or machine language so that the central processing unit receives instructions which it understands and can execute. This paper outlines the compiler construction course as it is taught at West Chester University, with emphasis on the compiler writing project assigned to the students.
An interactive tutorial system for MC68000 assembly language using HyperCard
Authors: Coey W. A.
Published: July 2004

Assembly language programming of the Motorola MC68000 microprocessor is taught to post-graduate students in the department of Computer Science at Queens University of Belfast in a course entitled "Microcomputer Architecture and Programming". Due to the large number and complexity of the 68000's instructions an interactive tutorial system was developed, using HyperCard and HyperTalk, to enhance existing teaching methods. The system, although aimed at courses teaching MC68000 programming, would be a useful introduction to low level programming theory on courses teaching computer architecture or assembly language programming.
Automatic system file generator
Authors: Vazquez Federico , Hanacek Guy
Published: July 2004

The Advanced Automation System is a large complex system for Air Traffic Control used by the Federal Aviation Administration and its development is expected to last several years. Data Structure Design will change throughout the development cycle during these years. The Automatic System File Generator (ASFG) is designed to ease the effect of this continuous change in design in the area of Data Analysis. ASFG allows the creation of system files from thousands of message types whose structure is in continuous modification and revision.The basic purpose of the ASFG is to allow the input of any kind of message type files and convert them to system files for use by the Report System that is implemented with the Statistical Package for the Social Sciences (SPSS).
Software reuse based on a large object-oriented library
Authors: Liao Hsian-Chou , Wang Feng-Jian
Published: July 2004

Object-oriented software libraries expand in size more rapidly than other type of software library. This paper presents a simple approach for aiding reuse in software development using object-oriented library. Our approach improves the effectiveness of code searching by reorganizing the library with facet classification scheme and thesaurus. Information in specification models, such as data flow diagrams (DFDs), is extracted through object abstraction and then used as a query input. We are currently implementing a Computer-Aided Reuse Tool (CART) based on the approach.
A domain-specific software architecture engineering process outline
Authors: Tracz Will , Coglianese Lou , Young Patrick
Published: July 2004

One of the dilemmas that has prevented software developers from resuing software is the lack of software artifacts to use or the existence of artifacts that are difficult to integrate. Domain-Specific Software Architectures (DSSAs) have been proposed[4] in order to address these issues. A DSAA not only provides a framework for reusable software components to fit into, but captures the design rationale and provides for a degree of adaptability. This paper
1
presents an outline for a Domain-Specifid Software Architecture engineering process.
A methodology for software cost estimation
Authors: Arifoglu Ali
Published: July 2004

Software Cost Estimation is an empirical process to be applied to find out basically the effort and development time requirements for the software product which is going to be developed. The process starts with the planning phase activities and refined throughout the development. It is very important for managing and scheduling the software project. Various cost estimation methods are available to be used for software development process. Depending on the size of the software, a macro (for the information systems requiring more than 30 man years to develop) or a micro cost model can be used for estimation. The paper discusses available work on the cost estimation methods and proposes a methodological view in cost estimation. Basically, the methodology involves; how to combine available cost estimation techniques to have better estimation and, how to apply the methodology through software development. In the application of the cost estimation techniques, SD (Structured Development/Design) methodology is assumed as applied during the development. Some of the observations in the experiments are also given in the paper.
Inertia—the reluctance of code motion?
Authors: Shu William S.
Published: July 2004

The effects of optimisation on debugging were characterised, first as metric-based distances along paths, and then within an algebraic framework [6, 7, 8]. In them, we observed algorithmic ambiguities which may seriously compromise the efficiency-though not the semantic definition-of a debugger for optimised programs. Informal observations appear to indicate enhanced performance if displaced codes were favoured for further displacements, and unmoved codes were preferentially left alone. This reluctance to change the "state of code motion" seems much like the physical quantity known as inertia. This paper highlights points to support the "inertial argument", and raises questions to be explored in relation to it.
Urgent research issues in software process engineering
Authors: Starke Gernot
Published: July 2004

This paper outlines the major problems and research directions in software process engineering. These problems concern the
terminology
and
language
of models; the difference between
type
and
instance
; the inherent
reflexivity
of detailed process models and the dynamic aspects of process models. Furthermore
human factors
are shown to impose major difficulties on process engineers.
Teaching tools for data structures and algorithms
Authors: Biernat Martin J.
Published: July 2004

This paper describes several teaching tools used in an Analysis of Algorithms course. The tools aid in reviewing data structures and explaining various algorithms while actively involving the student with the algorithms. These tools have helped students not only understand and retain the concepts behind the algorithms, but has also raised their level of interest in the class.
Object extensibility
Authors: Dixon Chip
Published: July 2004

This paper presents the object-oriented concept of extensibility. The specific implementation for this concept is the language Turbo Pascal (5.5 or later). The example illustrated has been successfully used as part of an introductory object-oriented programming class.
The integer square root of
N
via a binary search
Authors: Higginbotham T. F.
Published: July 2004

An algorithm is presented which may be used to find the integer square root of N. The method is intended for use on a binary computer, where only addition, subtraction, multiplication, or division by 2 is required. The problem arose when the author was working on factoring large numbers, where the machine, the Honeywell DPS 8, had double precision integer addition and subtraction, and the simulation of multiplication was easy. The actual factoring of the large number was to be Fermat's Method, requiring only addition and subtraction, but the integer square root is required in order to test for termination. The algorithm is implemented in FORTRAN for ease of reading.Students enjoy the unconventional approach to solving this problem. It isn't long before some of them think of other unusual solutions.
Co-oping at the super collider
Authors: Harrison William S.
Published: July 2004

This paper dicusses one student's experience as a participant in the Co-operative education program at the Superconducting Super Collider Laboratory in Dallas Texas.
Parsing as search
Authors: Harlan Robert M. , Patrone David M.
Published: July 2004

Developing laboratory assignments on natural language processing in an introductory AI course is difficult. One reason is that the interpreter that applies a grammar to input is often a complex, hard to understand system. One is forced either to treat the interpreter as a black box, restricting students to extending the grammar that it applies, or to spend an inordinate amount of time mastering the interpreter. We present an alternative that enables students to master an interpreter in fairly short order. Approaching parsing as a search problem, an interpreter is presented that is based on a search engine with which students have had previous experience. This paper discusses an interpreter for an RTN grammar. A subsequent paper shows how the interpreter can be modified to handle an ATN grammar. The grammar and interpreter are available via ftp.
Is eight enough?
Authors: Gray John S.
Published: July 2004

A detailed analysis of a classic backtracking problem, The Eight Queen Problem is presented. The paper addresses additional facets of the Eight Queen Problem that might be overlooked when casually generating a program solution. The author suggests that the extra time taken to fully analyze the problem will result in a better understanding of the problem which in turn will manifest itself in a better program solution.
Algebra and models
Authors: Hoare C. A. R.
Published: July 2004

Science makes progress by constructing mathematical models, deducing their observable consequences, and testing them by experiment. Successful theoretical models are later taken as the basis for engineering methods and codes of practice for design of reliable and useful products. Models can play a similar central role in the progress and practical application of Computing Science.A model of a computational paradigm starts with choice of a carrier set of potential direct or indirect observations that can be made of a computational process. A particular process is modelled as the subset of observations to which it can give rise. Process composition is modelled by relating observations of a composite process to those of its components. Indirect observations play an essential role in such compositions. Algebraic properties of the composition operators are derived with the aid of the simple theory of sets and relations. Feasibility is checked by a mapping from a more operational model.A model constructed as a family of sets is easily adapted as a calculus of design for total correctness. A specification is given by an arbitrary set containing all observations permitted in the required product. It should be expressed as clearly as possible with the aid of the full power of mathematics and logic. A product meets a specification if its potential observations form a subset of its permitted observations. This principle requires that all envisaged failure modes of a product are modelled as indirect observations, so that their avoidance can be proved. Specifications of components can be composed mathematically by the same operators as the components themselves. This permits top-down proof of correctness of designs even before their implementation begins. Algebraic properties and reasoning are helpful throughout development. Non-determinism is seen as no problem, but rather as a part of the solution.
Fine-grained revision control for collaborative software development
Authors: Magnusson Boris , Asklund Ulf , Minör Sten
Published: July 2004

This paper presents a framework for controlling the evolution of complex software systems concurrently developed by teams of software engineers. A general technique for fine-grained revision control of hierarchically structured information, such as programs and documents, is described and evaluated. All levels in the hierarchy are revision controlled, leaves as well as branch nodes. The technique supports sharing of unchanged nodes among revisions, automatic change propagation, and change-oriented representation of differences. Its use in a software development environment is presented, facilitating optimistic check-out of revisions and alternatives, check-in with incremental merge support, visualization of change propagation, and an integrated flexible diff-ing technique providing group awareness for team members.
PLEIADES
Authors: Tarr Peri , Clarke Lori A.
Published: July 2004

Software engineering environments impose challenging requirements on the design and implementation of an object management system. Existing object management systems have been limited in both the kinds of functionality they have provided and in the models of support they define. This paper describes a system, called P
LEIADES
, which provides many of the object management capabilities required to support software engineering environments.
Deriving modular designs from formal specifications
Authors: Carrington David , Duke David , Hayes Ian , Welsh Jim
Published: July 2004

We consider the problem of designing the top-level modular structure of an implementation. Our starting point is a formal specification of the system. Our approach is to analyse the references to the state variables by the operations of the system. Operations that reference/modify similar sets of variables are likely candidates for grouping into a module. We evaluate the strategy by applying it to a large Z specification of a language-based editor.
A framework for programming and formalizing concurrent objects
Authors: Bahsoun Jean Paul , Merz Stephan , Servieres Corinne
Published: July 2004

We propose an object-oriented programming model based on concurrently executing communicating agents which aims to achieve reusability and extensibility of agent descriptions by separating aspects of functionality and synchronization. A formal semantics of an agent is given as a theory in the Temporal Logic of Actions [15] such that a system of agents is formalized by the conjunction of the single agents' specifications plus some axioms representing the communication structure. This representation allows for the formal derivation of systems properties. We terminate this paper by a discussion about the proof of inheritance properties in a parallel environment.
A logical approach to data structures
Authors: Turpin Russell
Published: July 2004

The Galois project at the University of Texas is building a programming environment that supports the formal development and verification of data structure programs. This programming environment supports features such as pointer manipulation and destructive update that often make formal treatment difficult.
Test case generation by means of learning techniques
Authors: Bergadano F.
Published: July 2004

Given a program P and a set of alternative programs
P
, we generate a sequence of test cases that are adequate, in the sense that they distinguish the given program from all alternatives. The method is related to fault-based approaches to program testing, but programs in
P
need not be simple mutations of P. The technique for generating an adequate test set is based on the inductive learning of programs from finite sets of input-output examples: given a partial test set, we generate inductively a program P'
E P
which is consistent with P on those input values; then we look for an input value that distinguishes P from P', and repeat the process until no program except P can be induced from the generated examples. We show that the so obtained test set is adequate w.r.t. the alternatives belonging to
P
. The method is made possible by a practical program induction procedure, which has evolved from recent research in Machine Learning and Inductive Logic Programming.
Scalable software libraries
Authors: Batory Don , Singhal Vivek , Sirkin Marty , Thomas Jeff
Published: July 2004

Many software libraries (e.g., the Booch C++ Components, libg++, NIHCL, COOL) provide components (classes) that implement data structures. Each component is written by hand and represents a unique combination of features (e.g. concurrency, data structure, memory allocation algorithms) that distinguishes it from other components.We argue that this way of building data structure component libraries is inherently unscalable. Libraries should not enumerate complex components with numerous features; rather, libraries should take a minimalist approach: they should provide only primitive building blocks and be accompanied by generators that can combine these blocks to yield complex custom data structures.In this paper, we describe a prototype data structure generator and the building blocks that populate its library. We also present preliminary experimental results which suggest that this approach does not compromise programmer productivity nor the run-time performance of generated data structures.
Specifying operational profiles for modules
Authors: Woit Denise M.
Published: July 2004

We describe a technique for specifying operational profiles for modules. The technique is more general than those of the current literature and allows more accurate specification of module usage. We also outline an algorithm for automatically generating random test cases from any such operational profile specification for a module, such that the test cases correspond to a random sampling of the module's input in actual operation. Operational-based statistical estimations, such as operational reliability, may be more meaningful when our specification method and generation algorithm are used, because our method permits more precise specifications than do other methods in the current literature.
Test template framework
Authors: Stocks P. , Carrington D.
Published: July 2004

A framework for specification-based testing is demonstrated on a symbol table case study, specified using the Z notation. Test derivation and structuring is discussed, as well as applications of the framework in deriving test oracles and aiding regressing testing during maintenance. Areas for further research and discussion are comparison of heuristics with regard to generated test suites and usability, formalising testing heuristics, and the discrepancy between functional testing and robustness testing.
Abstract analysis with aspect
Authors: Jackson Daniel
Published: July 2004

Aspect is a static analysis technique for detecting bugs in code based on three forms of abstraction: declarative specification, data abstraction and partiality (ignoring some behavioural details). Together, they bring efficiency (the checker runs almost as fast as a type checker), modularity (a procedure can be analysed independently of the procedures it calls) and incrementality (allowing the checking of incomplete programs). Aspect can detect errors that are not detectable by other static means, especially errors of omission, which are pervasive but usually hard to detect.
Metric-driven reengineering for static concurrency analysis
Authors: Levine David L. , Taylor Richard N.
Published: July 2004

An approach to statically analyzing a concurrent program not suited for analysis is described. The program is reengineered to reduce the complexity of concurrency-related activities, thereby reducing the size of the concurrency state space. The key to the reengineering process is a metric set that characterizes program task interaction complexity and provides guidance for restructuring. An initial version of a metric set is proposed and applied to two examples to demonstrate the utility of the reengineering-for-analysis process. The reengineering has potential benefits apart from supporting analyzability, following the dictum that if it is hard to analyze, it is hard to understand and maintain.
Using state space reduction methods for deadlock analysis in Ada tasking
Authors: Duri S. , Buy U. , Devarapalli R. , Shatz S. M.
Published: July 2004

Over the past few years, a number of research investigations have been initiated for static analysis of concurrent and distributed software. In this paper we report on experiments with various optimization techniques for reachability-based deadlock detection in Ada programs using Petri net models. Our experimental results show that various optimization techniques are mutually beneficial with respect to the effectiveness of the analysis.
An integrated general purpose automated test environment
Authors: Vogel Peter A.
Published: July 2004

As software systems become more and more complex, both the complexity of the testing effort and the cost of maintaining the results of that effort increase proportionately. Most existing test environments lack the power and flexibility needed to adequately test significant software systems. The CONVEX Integrated Test Environment (CITE) is discussed as an answer to the need for a more complete and powerful general purpose automated software test system.
Efficient construction of program dependence graphs
Authors: Harrold Mary Jean , Malloy Brian , Rothermel Gregg
Published: July 2004

We present a new technique for constructing a program dependence graph that contains a program's control flow, along with the usual control and data dependence information. Our algorithm constructs a program dependence graph while the program is being parsed. For programs containing only structured transfers of control, our algorithm does not require information provided by the control flow graph or post dominator tree and therefore obviates the construction of these auxiliary graphs. For programs containing explicit transfers of control, our algorithm adjusts the partial control dependence subgraph, constructed during the parse, to incorporate exact control dependence information. There are several advantages to our approach. For many programs, our algorithm may result in substantial savings in time and memory since our construction of the program dependence graph does not require the auxiliary graph. Furthermore, since we incorporate control and data flow as well as exact control dependence information into the program dependence graph, our graph has a wide range of applicability. We have implemented our algorithm by incorporating it into the Free Software Foundation's GNU C compiler; currently we are performing experiments that compare our technique with the traditional approach.
The composability of ASTRAL realtime specifications
Authors: Coen-Porisini Alberto , Kemmerer Richard A.
Published: July 2004

ASTRAL is a formal specification language for realtime systems. It is intended to support formal software development, and therefore has been formally defined. In ASTRAL a realtime system is modeled by a collection of state machine specifications and a single global specification.

This paper focuses on extending the ASTRAL methodology to allow the composition of ASTRAL system specifications into specifications of larger and more complex systems.

The ASTRAL language includes structuring mechanisms that allow one to build modularized specifications of complex systems with layering. In this paper we concentrate on how to combine these complex system specifications into specifications of even more complex realtime systems. This is accomplished by adding a COMPOSE section to the language that provides the needed information to combine two or more ASTRAL specifications into a single new one.

In this paper we also introduce the necessary proof obligations to assure that the assumptions of each of the components of the larger system are satisfied by the other components of the system that replace the previous external environment. We also discuss how some exported transitions become internal transitions of the new system. A telephony example with local central controls that interface to long distance units is used to motivate the extensions.
An instructed tool for cache coherence protocols
Authors: Nájera Jerónimo , Gómez Luis
Published: July 2004

Several protocols have been proposed in order to solve the cache coherence problem. In all cases, it is very difficult to understand how each algorithm works. The tool ToCCata has been designed and developed to graphically show the dynamic behavior of generic cache coherence algorithms. ToCCata can be used for pedagogical or demonstration purposes.
Multibox parsers
Authors: Dyadkin Lev J.
Published: July 2004

Traditional compiler front end generating tools such as Lex/Yacc assume a front end consisting of two boxes: a lexical box and a syntax box. Lex produces a lexical analyzer using regular expressions as a token description. Yacc generates a syntax analyzer from the LALR grammar for the parsed language. This approach has big problems with such lexically and syntactically complex languages as Fortran. The main reason for these problems is that regular expressions, being equivalent to a right linear grammar, do not have the capability to describe the incredibly complex lexical structure of Fortran. As a result, compiler writers abandon Lex and produce handwritten lexers for Fortran, thus defeating the main purpose of the parser generator, automation.This work solves these problems by introducing a multibox parser, where each lower box modifies its input language to produce a more "straightened" output language for the higher box. The number of boxes reflects the complexity of the parsed language.For example, Fortran requires more boxes than does C. Each box is represented by an L-attributed translation grammar in simple assignment form with an LL(1) input grammar. LL(1) grammars were chosen for higher speed, smaller size, and because, unlike regular expressions, they can express constructs such as nested parentheses, a capability which is required for parsing Fortran on the lexical level. New operations for the LL(1) machine are added to ensure it is strictly forward moving, without backtracking in the parsed source code. We have extended the LL(1) grammars to "indexed LL(1) grammars."This enhancement allows more of the resulting code to be automatically generated, rather than handwritten. New parser generating tools have been developed by us to support this technology. The multibox approach has been implemented in the Lahey Fortran 90 compiler.
A new exercise in concurrency
Authors: Trono John A.
Published: July 2004

This article presents an exercise to be assigned whenever undergraduates are introduced to the concepts of concurrency and semaphores. It also presents several possible strategies to solve said exercise along with a "coded" solution.
Teaching computer science principles to liberal arts students using Scheme
Authors: Konstam Aaron , Howland John E.
Published: July 2004

The Scheme dialect of Lisp is being used as an expository notation in introductory courses for liberal arts students at Trinity University. Terminology from natural language identifying parts of speech, such as verb, noun, pronoun and adverb, is used to present Scheme syntax and semantics to non programmers. Simple working models of various computer science topics are described. Experiences from two Trinity computer science courses are presented.
Integrating “depth first” and “breadth first” models of computing curricula
Authors: Shackelford Russell L. , LeBlanc Richard J.
Published: July 2004

Traditional undergraduate Computer Science curricula have been increasingly challenged on a host of grounds: undergraduate computing education is attracting fewer majors, is not producing graduates who satisfy the needs of either graduate programs or business and industry, and is not effectively responding to the increasing needs for computing education among the larger student population. In the face of such challenges, there has been a recent movement to restructure undergraduate computing curricula.

At Georgia Tech we have design (AY 91-92) and implemented (AY92-93) a new computing curriculum that features a radical restructuring of subject matter. During the design and implementation process, we paid close and critical attention to the particulars of both the ACM recommendations and reports from our colleagues at other institutions who had already gained some experience with “Breadth First” approaches. We have conclude that curriculum modernization should integrate key aspects of both “Depth First” and “Breadth First” approaches. Our new curriculum is an example of such integration. We present data (measures of student performance and of student and faculty opinion) that confirm that our approach is viable, and we now believe that it can be a useful model for others. In this paper, we outline the structure of our integrated curriculum and report on key facets of our experience with it.
Two years of “The Digital World”
Authors: Fagin Barry
Published: July 2004

We report here our cumulative 2-year experience with the “The Digtal World”, a course designed to increase the technological literacy of non-science students. The course relies heavily on computer-aided instruction, including the extensive use of electronic lectures and multimedia. Students were able to acquire a surprising level of sophistication by working with examples of digital technology chosen from their daily lives. Students were also able to identify weaknesses in areas of current technology and public policy similar to those identified by experts.

We describe our successes and failures, and present cumulative data on performance, by major, class, and gender. All courseware and applications for “The Digital World” are available from the author.
Accreditation
Authors: Rozanski Evelyn P.
Published: July 2004

Accreditation, considered to be the one formal mechanism for assessing quality in the postsecondary environment, focuses on determining and encouraging acceptable levels of educational quality. In particular, specialized program accreditation is purported to enhance program quality.

This exploratory study used a nationwide mail questionnaire to a stratified random sampling of 100 department heads of the units administering baccalaureate Computer Science programs. The purpose was to gain an understanding of how Computer Science programs and departments were related to selected indicators of faculty and program quality.

Several differences and some similarities exist between the accredited and non-accredited groups. The median of the data for each indicator suggested a quality breakpoint to be used in defining two indices. It was found that for each of the two indices, the accredited group outperformed the non-accredited group by thirty percent. The implication is that Computer Science programs that follow accreditation guidelines have the potential for increasing their quality indicators.
Computing laboratories and the small community college
Authors: Tureman Robert L.
Published: July 2004

The small community college faces a unique set of challenges in laboratory implementation. This paper identifies the computing environment at a particular small community college, discusses the instructional content desired by the college, surveys various approaches to laboratories, and offers the approach that the college is using to implement appropriate instructional computing labs. The suggested approach provides for both an “OPEN” and “SCHEDULED” lab, promotes instructor freedom as no one lab approach is dictated by the lab setup, allows directed labs where they are appropriate and documents that class contact hours are set according to standards.
Concepts in the classroom, programming in the lab
Authors: Geitz Robert
Published: July 2004

Computing Curricula 1991
calls for breadth in the undergraduate computer science curriculum. Many authors have recommended structured laboratories for computer science. This is a report on a project to combine these goals in an introductory sequence of courses. We present two courses in which all programming is done in a laboratory environment, leaving the lectures for more conceptual material that ranges over a broad selection of topics. Student reactions to this project have been very positive—we have increased the number of students continuing with the major, as well as student satisfaction with the courses themselves.
Self-reference is an illustrative essential
Authors: Astrachan Owen
Published: July 2004

This paper includes an abstract, a discussion of the usefulness of self-reference in early computer science courses, and some examples to illustrate this usefulness. Most readers will not be troubled by this example of self-referential writing. Why then is self-reference, usually in the form of recursive subprograms, thought to be so onerous as to be placed in its own left-until-the-end-and-often-uncovered chapter in most introductory texts? Self-reference is one of the cornerstones of computer science from the unsolvability of the halting problem, to writing a Pascal compiler in Pascal, to reveling in the beauty of Quicksort. We argue that the notion of self-reference should permeate first courses in computer science. If this is to be the case such courses should take a view far broader than “Wow, I can average 10 numbers with the skills I learned in my first programming course!”
A psychological perspective on gender differences in computing participation
Authors: Clarke Valerie A. , Teague G. Joy
Published: July 2004

Any observant teacher of computer science at secondary or post-secondary level in an English-speaking country has probably noticed that there are considerably more boys than girls in the class. Many are concerned that there are able girls who would enjoy the challenge of a computing career who are choosing not to study computer science, students who may be more capable than many of the boys selecting these studies. The aim of this paper is to look at some of the factors which may influences the students' decisions to study computer science: the nature of the workforce, the prevalence of male and female role models, stereotyping of computing careers, culturally specific factors, perceived gender differences in ability, attitudes to computing, the organization of computing classes, approaches to assessment, and mentoring.
A three-fold introduction to computer science
Authors: Baldwin Doug , Scragg Greg , Koomen Hans
Published: July 2004

We have developed a new introduction to the computer science major, consisting of two courses, called Science of Computing 1 and Science of Computing 2. This sequence emphasizes balanced development of basic abilities in all three of computer science's fundamental methods of inquiry (design, theory, and empirical analysis), as opposed to the more traditional emphasis on programming and data structures. Science of Computing 1 introduces students to all three methods of inquiry, in the context of recursive algorithms and their mathematical and experimental analysis. Science of Computing 2 extends, and provides extensive practice in, all three methods. Both courses use a strongly hands-on approach to demonstrate the importance of, and interactions between, the three methods of inquiry. Preliminary results indicate that these courses successfully teach basic design, theory, and empirical analysis, and encourage students to continue studying computer science at a rate as high as or higher than that of traditional introductory courses.
Peer learning in an introductory computer science course
Authors: Wills Craig E. , Finkel David , Gennert Michael A. , Ward Matthew O.
Published: July 2004

A problem in teaching large introductory computer science courses is to overcome the impersonality of the large lecture class and to provide more personal attention to individual students. Our approach is to use peer learning experiences to instill in students the need to take responsibility for their learning and for the learning of those around them. Recent work has shown that educational quality for students and productivity for faculty can be enhanced through use of peer-learning environments where students do not just learn and faculty do not just teach.

The novel aspects of our work are to apply group learning in a large introductory computer science class setting and to expect more responsibility on the part of students for their learning. In support of these goals we have introduced the use of upper-level undergraduate students to help facilitate student group interaction. In addition, we have developed software to minimize the administrative overhead of handling many groups and for students to electronically record group learning activities.
Introducing undergraduates to object orientation using the Turing language
Authors: Holt Richard C.
Published: July 2004

Object-oriented programming was introduced in the 1980s and is now being used extensively in industry, but academia has not generally included it as a main stream topic for instruction. Part of the difficulty is the lack of good software to support teaching of object orientation. This paper describes an approach that teaches OO concepts across the Computer Science undergraduate curriculum, beginning in the introductory course, using the Object-Oriented Turing system.