bluuebunny/crossref_metadata_2025_split huggingface dataset:
Spreadsheets and databases—alternatives to programming for non-computer science majors
Authors: Bailey M. Gene 
Published: July 2004

Microcomputers have become easier and easier to use an emphasis is placed on software design for users with little or no experience. With a minimal amount of training, students or employees can become productive. Yet, academic programs still teach programming as a fundamental part of computer literacy. This paper proposes that the programming portion of the class be eliminated and replaced with a study of spreadsheets and databases. The paper discusses the manner in which spreadsheet and database design can be approached to maximize learning.
An important concept that is learned in any programming class is algorithm development. Students learn how to analyze the problem and to set up the step-by-step solution. This process must be done before any coding can begin. Spreadsheets offer the same type of learning and are much more appropriate for non-computer science majors. Students must formulate the problem, determine the equations and formulas necessary to solve it, and then set up the worksheet. Spreadsheet applications are found in every discipline and their design requires a minimal amount of computer knowledge and mathematics.
Learning to set up a database and design the queries necessary to obtain information from the database is a concept important to computer literacy. Once again, students learn to “program” by learning to construct their questions in a manner that is meaningful to the software package.
Components and generative programming (invited paper)
Authors: Czarnecki Krzysztof , Eisenecker Ulrich W. 
Published: July 2004

This paper is about a paradigm shift from the current practice of manually searching for and adapting components and their manual assembly to Generative Programming, which is the automatic selection and assembly of components on demand. First, we argue that the current OO technology does not support reuse and configurability in an effective way. Then we show how a system family approach can aid in defining reusable components. Finally, we describe how automate the assembly of components based on configuration knowledge. We compare this paradigm shift to the introduction of interchangeable parts and automated assembly lines in the automobile industry.
We also illustrate the steps necessary to develop a product line using a simple example of a car product line. We present the feature model of the product line, develop a layered architecture for it, and automate the assembly of the components using a generator. We also discuss some design issues, applicability of the approach, and future development.
Designing specification languages for process control systems
Authors: Leveson Nancy G. , Heimdahl Mats P. E. , Reese Jon Damon 
Published: July 2004

Previously, we defined a blackbox formal system modeling language called RSML (Requirements State Machine Language). The language was developed over several years while specifying the system requirements for a collision avoidance system for commercial passenger aircraft. During the language development, we received continual feedback and evaluation by FAA employees and industry representatives, which helped us to produce a specification language that is easily learned and used by application experts.
Since the completion of the RSML project, we have continued our research on specification languages. This research is part of a larger effort to investigate the more general problem of providing tools to assist in developing embedded systems. Our latest experimental toolset is called SpecTRM (Specification Tools and Requirements Methodology), and the formal specification language is SpecTRM-RL (SpecTRM Requirements Language).
This paper describes what we have learned from our use of RSML and how those lessons were applied to the design of SpecTRM-RL. We discuss our goals for SpecTRM-RL and the design features that support each of these goals.
Toolkits in first year computer science
Authors: Rasala Richard 
Published: July 2004

Traditional first year computer science courses teach the principles of computing using the basic features of some chosen programming language such as C, C++, Java, Ada, Scheme, Eiffel, etc. Abstraction and encapsulation focus on entities such as algorithms, functions, data structures, classes, objects, and closures that can be built directly on top of the raw language. If a facility such as windows and graphics is not directly available in the language then it is not used. This means that student exercises tend to look inward at computer science issues rather than outward to the exciting applications that show the breadth and power of computing.
The fundamental thesis of this article is that teaching students in the framework of powerful toolkits is essential to maintain student interest and is pedagogically important precisely because toolkits are a rich source of examples that illustrate the principles of computation. We hope to convince computer science faculty that the use of toolkits is imperative in a modern first year curriculum.
We will first discuss in general why toolkits are important. We will spice this discussion with some simple illustrations and with references to the use of toolkits by faculty at other institutions.
We will then describe the toolkits we have developed at Northeastern University and explain both what they do and why they are pedagogically valuable. We will see how toolkits enable students to do more interesting and effective work and how principles of design and algorithms can be demonstrated by the key components of the toolkits.
We will conclude with some general remarks and explain why the arguments made against toolkits do not have sufficient weight to change our conclusions. We will also give the web site address where our toolkits are available.
Verisim
Authors: Bhargavan Karthikeyan , Gunter Carl A. , Kim Moonjoo , Lee Insup , Obradovic Davor , Sokolsky Oleg , Viswanathan Mahesh 
Published: July 2004

Why are there so few successful "real-world" programming and testing tools based on academic research? This talk focuses on program analysis tools, and proposes a surprisingly simple explanation with interesting ramifications.
For a tool aimed at developers or testers to be successful, people must use it - and must use it to help accomplish their existing tasks, rather than as an end in itself. If the tool does not help them get their job done, or the effort to learn and/or use the tool is too great, users will not perceive enough value; the tool will not get significant usage, even if it is free.
This talk focuses on the often-overlooked consequences of this seemingly basic statement in two major areas: program analysis, and the work beyond core analysis that must be done to make a successful tool. Examples will be drawn from tools that have been successfully used in industry (sold commercially, and developed for internal use).
Automated Testing of Classes
Authors: Buy Ugo , Orso Alessandro , Pezze Mauro 
Published: July 2004

Programs developed with object technologies have unique features that often make traditional testing methods inadequate. Consider, for instance, the dependence between the state of an object and the behavior of that object: The outcome of a method executed by an object often depends on the state of the object when the method is invoked. It is therefore crucial that techniques for testing of classes exercise class methods when the method's receiver is in different states. The state of an object at any given time depends on the sequence of messages received by the object up to that time. Thus, methods for testing object-oriented software should identify sequences of method invocations that are likely to uncover potential defects in the code under test. However, testing methods for traditional software do not provide this kind of information.
In this paper, we use data flow analysis, symbolic execution, and automated deduction to produce sequences of method invocations exercising a class under test. Since the static analysis techniques that we use are applied to different subproblems, the method proposed in this paper can automatically generate information relevant to testing even when symbolic execution and automated deduction cannot be completed successfully.
Which pointer analysis should I use?
Authors: Hind Michael , Pioli Anthony 
Published: July 2004

During the past two decades many different pointer analysis algorithms have been published. Although some descriptions include measurements of the effectiveness of the algorithm, qualitative comparisons among algorithms are difficult because of varying infrastructure, benchmarks, and performance metrics. Without such comparisons it is not only difficult for an implementor to determine which pointer analysis is appropriate for their application, but also for a researcher to know which algorithms should be used as a basis for future advances.
This paper describes an empirical comparison of the effectiveness of five pointer analysis algorithms on C programs. The algorithms vary in their use of control flow information (flow-sensitivity) and alias data structure, resulting in worst-case complexity from linear to polynomial. The effectiveness of the analyses is quantified in terms of compile-time precision and efficiency. In addition to measuring the direct effects of pointer analysis, precision is also reported by determining how the information computed by the five pointer analyses affects typical client analyses of pointer information: Mod/Ref analysis, live variable analysis and dead assignment identification, reaching definitions analysis, dependence analysis, and conditional constant propagation and unreachable code identification. Efficiency is reported by measuring analysis time and memory consumption of the pointer analyses and their clients.
Finite state verification (abstract only)
Authors: Clarke Lori A. 
Published: July 2004

Ever since formal verification was first proposed in the late sixties, the idea of being able to definitively determine if a program meets its specifications has been an appealing, but elusive, goal. Although verification systems based on theorem proving have improved considerably over the years, they are still inherently undecidable and require significant guidance from mathematically astute users. The human effort required for formal verification is so significant that it is usually only applied to the most critical software components.
Alternative approaches to theorem proving based verification have also been under development for some time. These approaches usually restrict the problem domain in some way, such as focusing on hardware descriptions, communication protocols, or a limited specification language. These restrictions allow the problem to be solved by using reasoning algorithms that are guaranteed to terminate and by representing the problem with a finite state model, and thus these approaches have been called finite state verification. Systems based on these approaches are starting to be effectively applied to interesting software systems and there is increasing optimism that such approaches will become widely applicable.
In this presentation, I will overview some of the different approaches to finite state verification. In particular I will describe symbolic model checking, integer necessary constraints, and incremental data flow analysis approaches. The strengths and weaknesses of these approaches will be described. In addition, I will outline the major challenges that must be addressed before finite state verification will become a common tool for the typical well-trained software engineer.
Slicing concurrent programs
Authors: Nanda Mangala Gowri , Ramesh S. 
Published: July 2004

Slicing is a well-known program analysis technique for analyzing sequential programs and found useful in debugging, testing and reverse engineering. This paper extends the notion of slicing to concurrent programs with shared memory, interleaving semantics and mutual exclusion. Interference among concurrent threads or processes complicates the computation of slices of concurrent programs. Further, unlike slicing of sequential programs, a slicing algorithm for concurrent programs needs to differentiate between loop-independent data dependence and certain loop-carried data dependences.
We show why previous methods do not give precise solutions in the presence of nested threads and loops and describe our solution that correctly and efficiently computes precise slices. Though the complexity of this algorithm is exponential on the number of threads, a number of optimizations are suggested. Using these optimizations, we are able to get near linear behavior for many practical concurrent programs.
A compositional approach to statecharts semantics
Authors: Lüttgen Gerald , von der Beeck Michael , Cleaveland Rance 
Published: July 2004

Statecharts is a visual language for specifying reactive system behavior. The formalism extends traditional finite-state machines with notions of hierarchy and concurrency, and it is used in many popular software design notations. A large part of the appeal of Statecharts derives from its basis in state machines, with their intuitive operational interpretation. The classical semantics of Statecharts, however, suffers from a serious defect; it is not compositional, meaning that the behavior of system descriptions cannot be inferred from the behavior of their subsystems. Compositionality is a prerequisite for exploiting the modular structure of Statecharts for simulation, verification, and code generation, and it also provides the necessary foundation for reusability.
This paper suggests a new compositional approach to formalizing Statecharts semantics as flattened labeled transition systems in which transitions represent system steps. The approach builds on ideas developed for timed process calculi and employs structural operational rules to define the transitions of a Statecharts expression in terms of the transitions of its subexpressions. It is first presented for a simple dialect of Statecharts, with respect to a variant of Pnueli and Shalev's semantics, and is illustrated by means of a small example. To demonstrate its flexibility, the proposed approach is then extended to deal with practically useful features available in many Statecharts variants, namely state references, history states, and priority concepts along state hierarchies.
Automating first-order relational logic
Authors: Jackson Daniel 
Published: July 2004

An automatic analysis method for first-order logic with sets and relations is described. A first-order formula is translated to a quantifier-free boolean formula, which has a model when the original formula has a model within a given scope (that is, involving no more than some finite number of atoms). Because the satisfiable formulas that occur in practice tend to have small models, a small scope usually suffices and the analysis is efficient.
The paper presents a simple logic and gives a compositional translation scheme. It also reports briefly on experience using the Alloy Analyzer, a tool that implements the scheme.
Goal-driven combination of software comprehension approaches for component based development
Authors: Mittermeir Roland T. , Bollin Andreas , Pozewaunig Heinz , Rauner-Reithmayer Dominik 
Published: July 2004

This paper reports on our approaches to combine various software comprehension techniques (and technologies) in order to establish confidence whether a given reusable component satisfies the needs of the intended reuse situation.
Some parts of the problem we are addressing result from differences in knowledge representation about a component depending on whether this component is a well documented in-house development, some externally built componentry, or a COTS-component.
Managing variability in software architectures
Authors: Bachmann Felix , Bass Len 
Published: July 2004

This paper presents experience with explicitly managing variability within a software architecture. Software architects normally plan for change and put mechanisms in the architecture to support those changes. Understanding the situations where change has been planned for and recording the options possible within particular situations is usually not done explicitly. This becomes important if the architecture is used for many product versions over a long period or in a product line context where the architecture is used to build a variety of different products. That is, it is important to explicitly represent variation and indicate within the architecture locations for which change has been allowed.
We will describe how the management of variations in an architecture can be made more explicit and how the use of variation points connected to the choices a customer has when ordering a product can help to navigate to the appropriate places in the architecture.
A do-it-yourself instant compiler.kit
Authors: Abbott R. J. 
Published: July 2004

The theory of compiler-compilers is well known. Here we present a small collection of SNOBOL subroutines which make the SNOBOL pattern matcher a self-documenting instant compiler. All one need add are the syntax productions (as simple SNOBOL patterns mimicking BNF) and the associated (synthesyzing) semartic transformation in the form of arbitrarily simple SNOBOL programs.
The resulting compiler produces a complete (or partial at the usér's discretion) trace of the parse showing how the syntax matches or fails to match the input. After a match is achieved, the semantic rules are executed on the resulting parse tree. The execution of these rules too are optionally traced so that one has a full picture of just which transformations were performed at each node of the tree. Finally the parse tree is printed.
Toward the specification of programs
Authors: Mein William J. 
Published: July 2004

Much has been written lately on program design using a top down approach, decomposition and stepwise refinement. Most of these methodologies have been grouped under the general rubric of structured programming, see for example Computing Surveys, Vol. 6, Number 4, December 1974. Structured programming does not, however, give many insights into the general area of program specifications.
As a result of lack of specifications and having a definite need to write the specifications for a system containing some forty to fifty programs, we developed a set of specifications. This set will be elaborated on more fully in section three, but first I want to elucidate some minor points.
ALGOL68 instruction at Oklahoma State University
Authors: Hedrick G. E. 
Published: July 2004

At Oklahoma State University ALGOL68 is taught to students whose background in programming consists primarily of programming in FORTRAN. Frequently, they have had some experience with PL/1 although it is not so extensive as their experience with FORTRAN. PL/1 is usually the only block structured language to which the students have been exposed. The students who study ALGOL68 are typically seniors, although there are some graduate students, and an occasional lowerclassman. Almost none of these students has any experience with ALGOL 60 or any ALGOL-like language at the time he begins his study of ALGOL68. About half of them have had limited experience with formal specification of programming languages.
The students learn ALGOL68 in one of three formats depending upon the number of students enrolled at a given time. The most elaborate treatment is given when there are enough students to justify a faculty member spending one-quarter of his time teaching the class as a special topics lecture course. This is the mode of instruction that is preferred by the students. A smaller group of students covers the same material in a seminar format rather than a lecture format; the students in the seminar do not have the same access to faculty as do students in a special topics lecture course. The final mode of instruction is individual study; it is this instructional format which is used when only one or two students enroll for ALGOL68. In this format the students work almost entirely on their own except that they do have access to a faculty member when they cannot adequately resolve their questions.
An advanced undergraduate course in applied computer science
Authors: Lusk Ewing L. 
Published: July 2004

The purpose of this paper is to describe a senior level course in the applied computer science curriculum at Northern Illinois University. The course, Database and Data Communications, has been taught for four semesters, and enrollment has steadily grown.
The course has a number of purposes. The primary one is to acquaint students with the principles of modern database management and teleprocessing applications and to instill proficiency in the writing of application programs for at least two of the major software systems supporting such applications, IBM's Information Management System (IMS) and Customer Information Control System (CICS). A secondary purpose is to consolidate and extend knowledge and techniques learned in previous courses. Course content which fulfills this purpose includes structured programming in both assembler language and COBOL, applied data structures, and access methods not previously covered (BDAM and VSAM).
A demand paging simulator
Authors: Leinbaugh Dennis 
Published: July 2004

A simulator is presented that allows a student to quickly write a demand paging memory management system. The simulator provides a job stream, support routines (such as read a page into memory), extensive error checking and debugging, and performance evaluation.
This simulator is intended for a first course in operating systems to acquaint a student with the mechanics involved in demand paging or a second course where more time would be spent developing and evaluating page removal algorithms and job scheduling algorithms.
Evaluating introductory programming textbooks
Authors: Shneiderman Ben 
Published: July 2004

My father counseled me not to give advice to others. Inspite of that admonition, I have an irrepressible desire to make some highly subjective, potentially pompous remarks about introductory programming language textbooks.
During the past nine years I have evaluated dozens of manuscripts for eight publishers and hundreds of books for teaching term-length introductory courses in FORTRAN, BASIC, PL/I, PASCAL, COBOL and assembly languages. I have co-authored two FORTRAN texts and developed two independent study guides to programming. Each time I see a text, I make judgments by reacting to the material, rather than by comparing the material to a pre-determined set of criteria. In order to provide a “structured” review process (no computer-science oriented paper is complete without a reference to “structure”), I offer the following criteria for evaluating texts. This list is far from complete, but it is a beginning.