bluuebunny/crossref_metadata_2025 huggingface dataset:
Computing curricula 2001 how will it work for you?
Authors: Roberts Eric , Engel Gerald , Cover C. Fay , McGettrick Andrew , Chang Carl , Wolz Ursula
Published: July 2004

In the fall of 1998, the ACM Education Board and the Educational Activities Board of the IEEE Computer Society appointed representatives to a joint task force to prepare Computing Curricula 2001 (CC2001), the next installment in a series of reports on the undergraduate computer science curriculum that began in 1968 and was then updated in 1978 and 1991. Interim reports on the initial planning of the curriculum were presented at the SIGCSE symposium and the IEEE Frontiers in Education Conference in both 1999 and 2000. The CC2001 Task Force released its first draft report at the 2000 SIGCSE conference and plans to release its penultimate draft at SIGCSE 2001. The purpose of this session is to describe how we expect the recommendations of the report to apply in practice. The panelists represent a range of institutions and can therefore speak to the questions that audience members from similar institutions might have.
Computer science education in a Saudi Arabian university
Authors: Al-Salman Abdulmalik S. , Adeniyi Jacob
Published: July 2004

The computer science curriculum at a university in the Kingdom of Saudi Arabia is described and then compared to with the CSAC/ABET accreditation criteria. The comparison is needed to determine the relevance of the curriculum in view of the dynamism and perturbations arising from the reality of the real world and CSAC/ABET criteria. The curriculum emphasizes breadth and depth in the main areas of computer science education and makes systems and systems development as its main subject area of expertise. The policy to adopt breadth and depth was based on the fact that Saudi Arabia is a young and rapidly developing country and computer science education in the country is at its infancy. The pre-college curriculum in the kingdom is lacking in computer science. In addition, computer science is a rapidly developing field. The graduates from this program were expected to be pioneering professionals in the emerging market of computer employment in the kingdom. The curriculum attempts to serve as a catalyst, providing a platform for discussion, which hopefully will result into a feedback to us. We also hope that the curriculum will serve as a guidance to third world countries which are in the same circumstances with limited capabilities and resources who may want to address the critical issues involved in computer science education.
RELAX — the relational algebra pocket calculator project
Authors: Matos Victor , Grasser Rebecca
Published: July 2004

Database courses benefit from the abundance of commercial SQL systems available today. Unfortunately, the same cannot be said about the relational algebra query language. This article considers a lab experience to integrate the learning of these two important topics. In the process of implementing the project, the student acquires practical knowledge in areas such as database programming, parsing and compiling, dynamic SQL code generation, object linking and embedding technologies (OLE), and problem solving skills using the framework of relational algebra. This activity is applied to a traditional second semester database theory course and appears to be very beneficial to the student.
Survey of software engineering education
Authors: Werth L. H.
Published: July 2004

This study summarizes the software engineering course offerings of nearly one hundred universities responding to a recent survey. Information to determine the current state of software engineering education is tabulated and analyzed in order to support curriculum development and to determine deficiencies and future needs.Characteristics of the institutions are used to compare relative numbers, types and academic levels of course offerings. A history of course startups provides insight into the growth and direction of new classes. Instructor background is examined to determine current and future faculty support needs. Similarly, the use and availability of textbooks, automated tools, and other teaching materials are investigated for cours support requirements. Information on course format and project organization provides additional understanding of the structure of current software engineering courses.
A new look at an old problem
Authors: Ramberg Peter
Published: July 2004

A computer science placement exam was given to all computer science students enrolled in introductory courses at a four year university. The purpose was to determine what differences, if any, occurred in the scores of the students who eventually withdrew from the courses and those who finished the course. Also, an examination was made of final grades of the students in the courses and their scores on the placement exam.
Automated method-extraction refactoring by using block-based slicing
Authors: Maruyama Katsuhisa
Published: July 2004

Refactoring improves the design of existing code but is not complex to do by hand. This paper proposes a mechanism that automatically refactors methods of object-oriented programs by using program slicing. To restructure a method without changing its observable behavior, the mechanism uses block-based slicing that does not extract the fragments of code from the whole program but from the region consisting of some consecutive basic-blocks of the program. A refactoring tool implementing the mechanism constructs a new method that contains the extracted code and re-forms the source method that contains this tool, a programmer indicates only a variable of interest in the code that he/she wants to refactor and then selects a suitable method from among the candidates created by the tool. The programmer does not have to test the refactored code since the mechanism is based on data-and control-flow analysis. Thus the tool enables programmers to avoid manual refactoring whose process is error-prone and time-consuming
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.
Reusable component interconnection patterns for distributed software architectures
Authors: Gomaa Hassan , Menascé Daniel A. , Shin Michael E.
Published: July 2004

This paper investigates the design of reusable component interconnection in client/ server systems. In particular, the paper describes the design of component interconnection patterns, which define and encapsulate the way client and server components communicate with each other. This paper uses the Unified Modeling Language (UML) to describe the component interconnection patterns for synchronous, asynchronous, and brokered communication. When designing a new distributed application, the appropriate component interaction patterns may then be selected and reused.
Secure and efficient mobile agent application reuse using patterns
Authors: Tahara Yasuyuki , Toshiba Nobukazu , Ohsuga Akihiko , Honiden Shinichi
Published: July 2004

As wide-area open networks like the Internet and intranets grow larger, mobile agent technology is attracting more attention. Mobile agents are units of software that can deal with environmental changes and the various requirements of open networks through features such as autonomy, mobility, intelligence, cooperation, and reactivity. In addition, some people consider the agent technology as a promising solution to the reuse issue because of the aspect of the agents as highly adaptable software components. However, since the usual development methods of secure mobile agent applications are not sufficiently investigated, the technology is not yet widespread. In this paper, we propose a formal framework that supports mobile agent application development and reuse with consideration of the trade-offs between the security issues and the performance issues. In our framework, we design a mobile agent application by building a computational cost model and a security model, and combining patterns so that the combination satisfies the models. Therefore we can develop the application considering the security and the performance trade-offs. Since the models and the patterns are presented according to a formal framework, we can make sure that the pattern combination satisfies the models rigorously. In addition, if the security policy of the new environment is different from the old one in reusing the system in a new organization, we can easily modify and adapt the behavior because the pattern application can be figured out automatically by an algorithm.
XML implementation of frame processor
Authors: Wong Tak , Jarzabek Stan , Swe Soe Myat , Shen Ru , Zhang Hongyu
Published: July 2004

A quantitative study has shown that frame technology [1] supported by Fusion toolset can lead to reduction in time- tomarket (70%) and project costs (84%). Frame technology has been developed to handle large COBOL- based business software product families. We wished to investigate how the principle of frame approach can be applied to support product families in other application domains, in particular to build distributed component- based systems written in Object- Oriented languages. As Fusion is tightly coupled with COBOL, we implemented our own tools based on frame concepts using the XML technology. In our solution, a generic architecture for a product family is a hierarchy of XML documents. Each such document contains a reusable program fragment instrumented for change with XML tags. We use a tool built on top of XML parsing framework JAXP to process documents in order to produce a custom member of a product family. Our solution is cost- effective and extensible. In the paper, we describe our solution, illustrating its use with examples. We intend to make our solution available to public in order to encourage investigation of frame concepts in other application domains, implementation languages and platforms.
Identifying procedural structure in Cobol programs
Authors: Field John , Ramalingam G.
Published: July 2004

The principal control-flow abstraction mechanism in the Cobol language is the
perform
statement. Normally,
perform
statements are used in a straightforward manner to define parameterless procedures (where global variables are used to pass data into and out of procedure bodies). However, unlike most procedural constructs, distinct
perform
ed procedures can share code in arbitrarily complicated ways. In addition,
perform
s can also be used in such a way as to cause transfers of control that do not correspond to normal call/return semantics.In this paper, we show how a Cobol program can be efficiently transformed into a semantically-equivalent
procedurally well-structured
representation, in which conventional procedures (i.e., with the usual call and return semantics and without code sharing) and procedure call statements replace
perform
ed code and
perform
statements. This transformation process properly accounts for the non-procedural control flow that can result from ill-behaved
perform
statements.The program representation derived from our analysis can be used directly in program understanding applications, program restructuring tools, and inter-language translators. In addition, it can be used as the starting point for a variety of context-sensitive program analyses, e.g., program slicing.
Equivalence analysis
Authors: Liang Donglin , Harrold Mary Jean
Published: July 2004

Existing methods to handle pointer variables during data-flow analyses can make such analyses inefficient both in time and space because the data-flow analyses must store and propagate large sets of data facts that are introduced by dereferences of pointer variable. This paper presents
equivalence analysis,
a general technique to improve the efficiency of data-flow analyses in the presence of pointers. The technique identifies equivalence relations among the memory locations accessed by a procedure and ensures that two equivalent memory locations share the same set of data facts in a procedure and in the procedures that are called by that procedure. Thus, a data-flow analysis needs to compute the data-flow information only for a representative memory location in an equivalence class. The data-flow information for other memory locations in the equivalence class can be derived from that of the representative memory location. Our empirical studies indicate that equivalence analysis may effectively improve the efficiency of many data-flow analyses.
Physical type checking for C
Authors: Chandra Satish , Reps Thomas
Published: July 2004

The effectiveness of traditional type checking in C is limited by the presence of type conversions using type casts. Because the C standard allows arbitrary type conversions between pointer types, neither C compilers, nor tools such as
lint,
can guarantee type safety in the presence of such type conversions. In particular, by using casts involving pointers to structures (C structs), a programmer can interpret any memory region to be of any desired type, further compromising C's weak type system. Not only do type casts make a program vulnerable to type errors, they hinder program comprehension and maintenance by creating latent dependencies between seemingly independent pieces of code.To address these problems, we have developed a stronger form of type checking for C programs, called
physical type checking.
Physical type checking takes into account the layout of C struct fields in memory. This paper describes an inference-based physical type checking algorithm. Our algorithm can be used to perform static safety checks, as well as compute useful information for software engineering applications.
Query by outlines
Authors: Balmas Françoise
Published: July 2004

We propose a new paradigm to query information about programs, namely
query by outlines.
This paradigm relies on an outlining model that conceptually describe units of code according to the computations they perform. Outlines are automatically constructed by our system PRISME for C and Lisp programs. Currently, both our model and our system are restricted to loops.QBO is a prototype tool that implements the query by outline paradigm. It proposes to browse the loops of a program directly through their outline, and allows to restrict these loops to browse with queries expressed as constraints on the outlines. Thus it enables to answer questions such as "where is this variable modified?", "where is this kind of computation performed?", or "are there many places where this computation is performed?".In this paper, we sketch our outlining model, introduce QBO and argue that
query by outline
is a helpful paradigm to manage programs.
GIDTS
Authors: Kókai Gabriella , Nilson Jörg , Niss Christian
Published: July 2004

This paper puts forward the Graphical Interactive Diagnosing, Testing and Slicing System (GIDTS) which is a graphical programming environment for PROLOG programs. TheIDTSpart of the system integrates Shapiro's Interactive Diagnosis Algorithm with the Category Partition Testing Method (CPM) and a slicing technique performing thealgorithmic debuggingandfunctional testingof PROLOG programs. The integration ofIDTSwith a graphical user interface (GUI) supports the whole functionality ofIDTSand provides a user-friendly environment giving the user more information on the state of the debugging process.GIDTSextendsIDTSto a complete programming environment. It allows one to handle the debugging of complex programs using theextendedsyntax and semantics of PROLOG in a very flexible way. A static code diagnosis has also been implemented. In additionGIDTSsupports debugging-directed editing of the source program, and a quick source code navigation via any of the tools (for example: the debugger, the static call graph and the information retriever). All these features are supported by the graphical user interface.
Benefits of a data flow-aware programming environment
Authors: Steindl Christoph
Published: July 2004

Many programmers write their programs with a primitive text editor that has no knowledge about the edited text. On the other hand, they use ingenious compilers that collect control flow and data flow information to perform optimizations and generate optimized code. We argue that program editors should have the same knowledge about the control flow and data flow of a program. Such editors could help programmers to better understand programs and to be more productive. We propose a data flow-aware programming environment that makes the information that the compiler already computed visible. The bidirectional feedback from the compiler to the programmer and back from the programmer to the compiler enables productive programming and faster debugging.
Evaluating software engineering methods and tool part 1
Authors: Kitchenham Barbara Ann
Published: July 2004

In the last five issues of SIGSOFT Notes, Shari Lawrence Pfleeger has discussed the use of formal experiments to evaluate software engineering methods and tools [1]. Shari's articles were based on work she performed for the U.K. DESMET project which aimed to develop a methodology for evaluating software engineering methods and tools.The DESMET project identified a number of useful evaluation methods in addition to formal experiments, and Shari asked me to continue this column by describing some of other methods. As a starting point, I will give an overview of the scope of the DESMET methodology in this article and describe the nine different evaluation methods DESMET identified. In the next few articles I will discuss criteria for selecting a specific method in particular circumstances. Later I will present the DESMET guidelines for performing quantitative case studies and feature analysis.
Workshop summary second international workshop on requirements engineering
Authors: Pohl Klaus , Peters Peter
Published: July 2004

As achieving high quality means the realization of customers needs, requirements engineering (RE) is the most crucial phase within software development. During RE not only the functional requirements but also the so-called 'non-functional' requirements of the planned software system have to be elicited from the customer and represented in a requirements document in order to provide the software designer with a complete and correct specification. Conventional RE methods normally support only parts of this process or help stating only specific kinds of requirements.These methodological problems are the prime motivation for the REFSQ workshop series held in conjunction with the CAiSE Conference on Advanced Information Systems Engineering. In order to find solutions which handle the described deficiencies it is the goal of this workshop series to improve the understanding of the relations between RE and software quality.This year's workshop, REFSQ'95, was held in conjunction with CAiSE'95 in Jyvaskyla, Finland on June 12th and 13th 1995.After the reviewing process we accepted 12 out of the 18 papers submitted. Finally, 11 full and position papers were presented at REFSQ'95 and discussed with the 15 participants (including the organizers). The participants came from 9 different countries.
Multi-agent object level AI validation and verification
Authors: Nourani Cyrus F.
Published: July 2004

A Methodology for validation and verification of AI systems in aerospace is presented. The approach is applicable to both systems that are already coded and to those that are to be designed. Design methods are proposed that can be applied to (reverse projected from) AI systems that are designed in the field and already coded. We note that there are well-developed software validation and verification methods that can be applied to the AI systems if an appropriate methodology is applied for validation of AI systems. Thus rather than reinventing methods for AI validation, we only invent methods to allow us to reduce to known problems in software validation and verification methodologies.
A learning curve primer for software engineers
Authors: Raccoon L. B.S.
Published: July 2004

I believe that many software engineers have heard of learning curves. We know that new skills take time to learn, that developers take a while to ramp up on a new project, and that improvement slows as time goes on. I also believe that we share many misconceptions about learning curves. We don't assume that learning curves are relevant to our software projects and we don't use them in our processes. In this paper, I want to raise the level of understanding of learning curves within the Software Engineering community. This paper is for managers and developers who want to better understand learning curves.Learning curves are much more than a hurdle to full productivity. They are both a metaphor and a specific set of equations that describe the most common patterns of improvement within stable processes. Learning curves explain why the productivity of a stable process changes the way that it does, why productivity is lowest at the start of a project and highest at the end of a project. Learning curves explain that though the improvements diminish throughout the process, the improvements continue adding up. And, we can use learning curves to predict future productivity.This paper is laid out as follows. In the first section, I define learning curves, describe their history, and argue that they apply to Software Engineering. In the second section, I describe the need to both stabilize and improve a process. Our concept of process influences how we try to improve it, so I discuss the implications of two different concepts of process. Learning curves denote the relationship between stability and improvement. In the third section, I discuss the implications of learning curves on staffing a project. Specifically, I show that Brooks's observations about man-months can be explained in terms of learning curves and that we need to keep teams together on long-term projects. And in the fourth section, I comment on several technical issues one might encounter when applying learning curves to software development. I describe the equations one might use to model a process as well as the affect learning curves typically have on software engineering projects.
Minicomputer selection and implementation
Authors: Stoddard Spotswood D.
Published: July 2004

Technological advances in large-scale integrated circuits have caused mini and micro computer usage to multiply in the last few years. This behooves academic to treat the mini/micro phenomenon adequately. The same multiplication process, however, makes choosing a minicomputer all the more difficult. The problem is compounded by the hardware and electronics knowledge required to attain the best price advantage. This paper describes how one academic computer department selected and implemented a minicomputer on a restricted budget. It is written primarily for the reader without extensive knowledge of hardware electronics.

This article is a description of the experiences of one academic computer department
1
in buying, installing, and using an academic minicomputer. It is directed primarily to those having little or no expertise in electronics or computer hardware design. This description is in response to a number of inquiries of “What did you do?” It is a step-by-step description and, as such, is quite specific to our particular system, with which we have been well pleased. It is offered as a guide of experience both to those who might obtain a similar system and as a case to others as well.
A logical approach to teach digital computer design at logic and systems level
Authors: Vishnubhotla Sarma R.
Published: July 2004

Design courses in Computer Systems Design are being taught in many undergraduate programs both for Computer Science and Electrical Engineering students. A design project is explained in this paper to give all the information to the students regarding the important concepts in both logic and systems level. The computer has sixteen instructions, two K memory and a single index register. This project can also be enlarged by introducing many extra hardware features.
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.
Teaching problem solving and structured programming in FORTRAN
Authors: Friedman Frank L. , Koffman Elliot B.
Published: July 2004

This paper describes an approach towards teaching problem solving in an introductory service course using the FORTRAN programming language. The course is centered around s set of problems which are used to illustrate a problem solving methodology. Three pedogogical tools (data table, flow diagram, and program system chart) are used to provide a framework for algorithm development. Two control structures (the Block IF decision structured and WHILE loop) have been added to the FORTRAN language to facilitate the implementation of algorithms.
An operating systems implementation project for an undergraduate course
Authors: Ruschitzka Manfred
Published: July 2004

While the adoption of an implementation project for an operating systems course is certainly beneficial, non-trivial projects are inherently demanding in terms of student efforts and computer costs. This paper reports on a project which has been designed to keep the effort for an extensive simulation of a contemporary system within acceptable limits. The project involves both a hardware simulator and an operating system, and a considerable reduction of the overall effort could be achieved by enhancing the hardware with operating systems support features. The design criteria as well as the characteristics of the resulting hardware configuration and operating system are presented, and the value of the project as a teaching tool is discussed
Operating systems with POPSS
Authors: Coulter Neal S.
Published: July 2004

It is often difficult to select relevant and reasonable laboratory assignments in an introductory operating systems course. The students are seldom prepared to code intricate portions of an operating system, even if suitable hardware were available for such extensive use. Nevertheless, it is essential that the students gain a quantitative insight into the components and interactions of simple and complex operating systems. An operating system simulator that allows an evaluation of the performances of various operating system configutations without requiring the student to write complicated code would help to solve the dilemma. An operating systems simulator named POPSS is a fine tool for such such use.
Teaching programming to beginners
Authors: Taylor Robert P.
Published: July 2004

Because of the rapid growth of computing and its influence in schools and community colleges, we find we must teach a growing number of graduate teachers and administrators how to program. Because we firmly believe that the only programming worth doing is well-structured programming, this is the sort of programming we want to teach these graduates to do. Because BASIC, FORTRAN, and COBOL are so widely implemented around the world, we know that one or more of these languages will be the ones most of our students will end up programming in, after they leave Columbia. Because such languages are not particularly well-suited for teaching structured programming to beginners, we decided to develop an indirect approach to this goal, one which would make the learning of these languages the learning of
second
languages in a second phase of learning to program. The approach which we have been developing, including the major components of a
first
programming language - FPL, is suggested in the remainder of this paper. For us, it has proven to be an indirect but effective way to teach raw beginners how to write well-structured programs in archaic, ill-designed, high-level real languages.
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.
Machine language programming in an undergraduate computer science curriculum
Authors: Sommerville Ian
Published: July 2004

This paper examines the advantages and disadvantages of teaching machine language programming to computer science undergraduate students. A teaching language based on reverse Polish notation, but with high-level control constructs, is presented as an alternative to conventional assembly language. Experiences with using this language are described.
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.
Methodology for teaching introductory computer science
Authors: Oldehoeft R. R. , Roman R. V.
Published: July 2004

In the last few years it has been generally recognized that teaching programming involves more than describing a new FORTRAN statement each day and providing programming problems to be coded. The concepts of disciplined programming and the accompanying interest in the problem solving process, coupled with the increasing economic desirability of constructing correct and maintainable software has resulted in significant attention being focused on
what
should be taught, and, to a lesser extent, on
how
this is best accomplished.

In order to discuss how an introductory programming course is taught, it is essential to first establish a set of objectives for such a course. Some of these objectives are obvious and generally agreed upon, others are engendered by the academic environment in which this particular course exists. We first state the objectives and then comment on their appropriateness and interrelation.
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.
A concept-oriented approach to introductory computer science
Authors: Conner William M.
Published: July 2004

A framework on which a concept-oriented introductory computer science course can be based is presented and our experience in offering such a course to a special group of high school students is described. It is suggested that introductory college-level courses should be based on this or a similar framework and our reasons for this suggestion are given.
A structured introductory computer science course
Authors: Winslow L.
Published: July 2004

A step-by-step presentation for the introductory computer science course which introduces the student to structured problem solving has been developed. By emphasizing the importance of “finding the pattern” and developing sequential algorithms from a top-down point of view, the students seem to have a better grasp on how to solve a problem, how to use a language, and how to apply what they have learned to later courses which use the computer.
Training college faculty members in the educational uses of computers
Authors: Morrison Louise S.
Published: July 2004

The problems encountered in training faculty members in the instructional uses of computers are explained. How to establish a successful training program is detailed, including organization of the course and its content.
Some thoughts on reasons, definitions and tasks to achieve “functional” computer literacy
Authors: Neill Michael J.
Published: July 2004

Computer literacy, according to Richard Austing (1), is a major category of computer science education. Although computer literacy potentially involves the greatest number of people, achieving an ongoing program presents computer educators with formidable problems. My concern is with the concept of “functional” computer literacy, that is, a level of computer literacy expected of everyone living in a computer society. Functional computer literacy can be developed by implementing a curriculum for junior and senior high school students. Two requirements for achieving a computer literacy curriculum are 1) to develop a philosophy which is both “computer” and “literacy” and 2) to identify minimum requirements for being computer literate.
Teaching hardware and computer design in a software oriented computer science program
Authors: Salomon David
Published: July 2004

A computer hardware and design course is described which is oriented toward softies. The special problems of such a course are discussed, some solutions offered, and the students' responses are analyzed.
“Recommended mathematical topics for computer science majors”
Authors: Davis Ronald L.
Published: July 2004

Although there is not universal agreement on a definition of computer science, I believe that it is the inclusion of a quantitative (mathematical) approach to our discipline that distinguishes “computer science” from “computer programming”. Mathematics provides both an established language with which to precisely define terms and established methods for problem solving. For example, the rather vague statement that “algorithm A is better than algorithm B” may be formulated unambiguously and verified or refuted with respect to certain performance measurements using the formalism of algorithm analysis (l). Mathematical methods also point toward the possibility of
proving
that an algorithm provides acceptable performance for large classes of inputs, a conclusion which often cannot be supported on the basis of case-by-case testing (5).

I will now discuss certain mathematical ideas which naturally arise in computer science courses and cite relevant examples which will hopefully convince the reader that these ideas are worthy of formal study. Suggestions are then offered regarding the inclusion of these studies in the four-year computer science curriculum.
The writing of an assembler in the programming language course
Authors: Bash Joyce M.
Published: July 2004

Computer Science students at CSI undertake a project to write a BAL
assembler as part of the Programming Language course. In this paper we describe an approach which allows the students not only to complete the writing of the assembler but also to execute the object code they generate. An evaluation of the success of the project will be included.
The laboratory in a computer science program
Authors: Ripley Jerald L. , Grout Jarrell C. , Hyams Denis M.
Published: July 2004

This paper discusses the role of a laboratory in a computer science pr ogram. Recommendations are made concerning facilities which may feasibly be included in the laboratory. A computer science practitum, which makes use of the laboratory facilities, is described and is proposed for inclusion in the curriculum.
Teaching honor students
Authors: Hightower Vicki M.
Published: July 2004

The introductory course in data processing and computer programming as taught at Elon College is first, a strong introduction to structured programming in BASIC and second, a look at the business side of data processing. It is an attempt to expose students to the terminology of computers and their uses and also get them acquainted with some of the standard concepts of computing algorithms and problem solving. Students use the DEC PDP 11/34 for this first course and no attempt is made to teach line editing with EDT. There is such a wide range of abilities in this course that we try to gear the material so that most students will have a positive experience and frustrations will be kept to a minimum.
Off campus computing
Authors: Oliver Dave
Published: July 2004

This paper describes an approach to teaching college level computer programming with particular reference to off campus students at the Capricornia Institute of Advanced Education (C.I.A.E.). It outlines the methods which are adopted to present the course to students studying at very great distances from the campus. Also the difficulties associated with providing the external student with access to adequate computing facilities are considered.
A cooperative development effort of a computer science program
Authors: Ward Darrell L.
Published: July 2004

The development of a Computer Science program in an era of economic uncertainty and general enrollment declines is presented. The cooperative efforts necessary in such a situation are described in detail and the interesting curricula which culminated from these efforts are presented in the Appendices.
The physical symbol system hypothesis of Newell and Simon
Authors: Ourusoff Nicholas
Published: July 2004

The essay below deals with Newell and Simon's hypotheses about the nature of intelligent action. The material is suitable for a classroom demonstration of artificial intelligence at the high school level and above.Discussion questions following the essay are designed to encourage making explicit connections between computer science, philosophy, and the life sciences. They are part of an effort to formulate an information-oriented, algorithmic view of nature.
Machine assisted marking of programming assignments
Authors: Benson M.
Published: July 2004

A machine assisted grading approach for computing assignments is described. The procedures used have proven effective for large groups of students (eg. 150). We concentrate on the administration of such a system. Success depends heavily on on how special cases are handled.
Procedures and comments vs. the banker's algorithm
Authors: Tenny Ted
Published: July 2004

A 2 × 2 factorial experiment was performed to compare the effects of modularity (using internal procedures) and comments on the readability of the Banker's Algorithm. The readability of 4 editions of the program, each having a different combination of these factors, was inferred from the accuracy with which students could answer questions about the program after reading its text. Results of the experiment suggest that the Banker's Algorithm is more readable with in-line code than with internal procedures, and that the author's comments improve its readability.
An experience in teaching disciplined programming at an elementary level
Authors: Friedman Frank L.
Published: July 2004

Several difficulties in teaching disciplined programming at an elementary level are mentioned. In particular, a minimum set of flow chart control structures for disciplined programming are described, and the problem posed by attempting to use these structures in conjuction with FORTRAN in an elementary computer programming course is discussed. A solution to this problem is presented in terms of a
structure oriented
extention to FORTRAN called NSFTRAN. The structured statement forms of NSFTRAN are described, and the motivations for the structure orientation are given. The main feature of NSFTRAN is its use of the numeric FORTRAN statement label as a
structure range identifier
as in the FORTRAN indexed DO statement.
Why a separate computer facility for computer science education? Experiences at the UW computer sciences teaching laboratory
Authors: Golde Hellmut , Shaw Alan
Published: July 2004

The University of Washington has supported a dedicated computer
facility for its graduate program in Computer Science since 1969; this facility is separated from the central University Computer Center. We have accumulated a reasonable amount of experience in using this laboratory for research and teaching. It is the purpose of this paper to describe our activities and experiences, and how they have affected our graduate program. Our main conclusion is that the separate facility is a tremendous resource from the points of view of our students, the faculty, and the potential employers of our graduates, and well worth the additional cost.
An instructionally acceptable cost effective approach to a general introductory course
Authors: Unger E. A. , Ahmed N.
Published: July 2004

This paper describes one approach to answering the need for an
introductory computer science course which will appeal to a university-wide audience. Kansas State University as many other institutions was faces with such a chllenge when financial constraints became more rigid. A large influx of students entered the Computer Science program, and many other units within the University recognized the need for some preparation for their students in Computer Science. Over a period of three years the course discussed was developed with large lectures and small laboratories. It is a cost-effective solution that caters to the needs of various disciplines.
An experimental course in advanced programming methods
Authors: Williams Kenneth
Published: July 2004

An experimental graduate course where students learn good programming and system design techniques through writing systems of programs in chief-programmer teams (CP-teams) is described. The course seems very worthwhile. Some of the things learned by students and the instructor are described, appropriate changes for the next offering of a similar course are described.
Computer attitudes
Authors: Slonneger K.
Published: July 2004

Students in a beginning computer science course were surveyed concerning their attitudes toward computers. Two statistical tests showed results: there were significant differences in attitudes from before until after the course, and between students who passed the course and those who failed or dropped. No correclation was evident between the opinions surveyed and the grades received by individual students.