bluuebunny/crossref_metadata_2025 huggingface dataset:
A reductionist approach to a course on programming languages
Authors: Wick Michael R. , Stevenson Daniel E.
Published: July 2004

The Programming Languages course is often a critical turning point in an undergraduate education where students begin to think more abstractly about programming languages and the design paradigms that use them. Traditional approaches to presenting this material often fail to achieve a number of important goals. We present an approach to Programming Languages that uses a single demonstration language (Scheme) and a collection of fundamental building blocks to study a variety of programming paradigms.
Kaleidoscope
Authors: Wick Michael R.
Published: July 2004

Most computer science curricula include design patterns during the junior/senior software development sequence. We present a simplified application of two classic design patterns that is specifically targeted at students in their first programming course. We also include suggested pedagogy on how to develop the concepts necessary to implement and appreciate the application.
A CS/SE approach to a real-time embedded systems software development course
Authors: Clifton Joseph M.
Published: July 2004

This paper describes an approach to a course in real-time embedded systems that focuses on software development issues. The course attempts to integrate topics from traditional computer science, infuse software engineering principles, and give some exposure to hardware concerns. Another important component of the course is experience with developing software for multiple platforms.
Integrating an intensive experience with communication skills development into a computer science course
Authors: Pollock Lori
Published: July 2004

This paper describes how a technical computer science course was transformed into an intensive communication skills course without sacrificing the technical content of the course. By integrating this experience into existing technical courses, the acquired skills are specific to the CS context without requiring an additional course. The main contribution of this paper is a set of activities which are targeted to building communications skills required for successful research in computer science at any level, but also generally useful for computer science students entering careers not involving basic research. We describe the specific methods and tools implemented in a way to provide considerable support, guidance, and feedback to students without a large investment by the professor.
A java API for historical ciphers
Authors: Morelli Ralph , Walde Ralph , Marcuccio Gregg
Published: July 2004

This paper describes a project suitable for a software engineering or object-oriented design course. The project consists of asking students to design an
application programming interface (API)
for a particular range of applications. An API-design project has several features not always found in application-design projects: It forces students to focus carefully on the distinction between the programming and the user interfaces; it provides a good justification for studying existing APIs as model code; it provides a natural way to divide tasks between different groups of designers/programmers; and, the final product can be used as the basis for programming projects in other courses. In this case the particular project we describe is the design of an API for implementing Historical Cipher algorithms.
Starving philosophers
Authors: Robbins Steven
Published: July 2004

Textbook discussions of synchronization seldom go beyond a brief introduction in terms of classical problems. This paper presents a simulator for the monitor solution of the dining philosophers problem that students can use to experimentally explore how such a solution might behave in practice. The simulator, which can be run remotely from a browser or can be downloaded for running locally, is written in Java so that it can be run on almost any system.
Experiences with tutored video instruction for introductory programming courses
Authors: Anderson Richard , Dickey Martin , Perkins Hal
Published: July 2004

In this paper we describe our experiences of exporting our introductory programming courses to community colleges. We used Tutored Video Instruction (TVI) as the mode of instruction where recorded versions of our lectures were shown to groups of students with local instructors periodically stopping the lecture for questions and discussion. We have offered a total of 16 sections of TVI courses, 11 were of our first quarter programming course (CSE142), and 5 were of our second quarter programming course (CSE 143). The courses were offered at seven institutions. Approximately 180 students completed the courses.We identify factors which contributed positively and negatively to the use of TVI for introductory programming courses. The two most important changes to our TVI program based on these experiences will the use of studio produced lectures and the abandonment of centralized course administration.
Identifying an appropriate view of software components for undergraduate education
Authors: Parrish Allen , Hollingsworth Joe , Maurer Peter , Shults Benjamin , Weide Bruce
Published: July 2004

Software components have existed in one form or another for a number of years. Work in this area can be classified into two broad categories. On the one hand, a number of researchers have approached the concept of software components from a first principles perspective, advancing ideas regarding what constitutes the ideal component paradigm from perspectives of efficiency, verifiability and reusability. On the other hand, recent commercial advances in a number of popular technologies have elevated the software component concept into widespread use within the software practitioner community. Such technologies include a number of technologies made popular by Microsoft (such as Active-X, COM, DCOM and Visual Basic), as well as CORBA and Java Beans.Neither of these perspectives on software components has become a standard cornerstone of software development pedagogy. Yet both perspectives may have an important role in preparing software developers to build high-quality software in the context of modern software development technologies. In particular, teaching students how to design and construct software components from first principles provides students with important guidance as to the "right way" to structure correct and efficient software systems (i.e., with emphasis on "what" component-based systems should contain). On the other hand, teaching students about current commercial component technologies exposes students to the important dimension of best commercial practice (i.e., with emphasis on "how" component-based systems could be built).The participants of this panel are all actively involved in the development of courses and curricula that provide various perspectives on component-based systems. They represent both the first principles and commercial perspectives discussed above. Position statements for each of the panelists appear below.
Programming early considered harmful
Authors: Hitchner Lewis E. , Gersting Judith , Henderson Peter B. , Machanick Philip , Patt Yale N.
Published: July 2004

The premise of this panel is that most introductory Computer Science courses are too narrowly focused on teaching students a programming language. This is a controversy that has been debated for years, but in recent years seems to have been forgotten. The writers of Computing Curricula 1991 stated:"Many feel that the amount of attention traditionally paid to the syntax of a programming language in the first course is excessive, and ought to be replaced with a more balanced introduction to the discipline. For these reasons,
PR: Introduction to a Programming Language
is defined as a separate knowledge unit in Part II, but is not a
required
part of the common requirements. "[1]This panel will present a review of current, typical first year courses and evidence for the case against focusing those courses on the teaching of a programming language. Next, each panelist will present his or her philosophy for a first course, followed by details of the courses at their school that implement their view, and conclude with outcomes and evidence of success of the courses.The panel includes four experienced CS-1/CS-2 educators, two of whom are members of the Computing Curriculum 2001 Pedagogy Focus Group on Introductory Courses and Topics (including the chair), and two of whom are authors of introductory texts that do not focus on teaching a programming language.
Collaboration vs plagiarism in computer science programming courses
Authors: Stewart-Gardiner Carolee , Kay David G. , Little Joyce Currie , Chase Joseph D. , Fendrich John , Williams Laurie A. , Wolz Ursula
Published: July 2004

In some circles, all programming is collaborative, yet in many CS1 and CS2 courses, individual programming assignments are made, collaboration with other students is cheating, and tailoring a program found on the web is plagiarism. Many educators feel that collaboration belongs only in a very few upper division courses. Others have experience to show that early collaboration broadens the learning of students, to become more effective professional individuals. Most conclude that a blend of the two styles is best for students, and can reduce cheating/plagiarism.Does collaboration belong in programming classes? Where does collaboration end and cheating/plagiarism begin? What are the advantages, problems and techniques of allowing collaboration on programming assignments in CS1 and CS2? The moderator created six discussion questions. Each member of the panel has chosen the position they can strongly support from experience. This panel will discuss these questions in detail among the panelists and audience.
Writing a textbook
Authors: Dale Nell , Mercer Rick , Koffman Elliot , Savitch Walter
Published: July 2004

Writing my first textbook was an eye-opening experience. I had to dig deep. I had ideas I was excited about and found others that were excited about them as well. I also found strong opposition to my approach, which was difficult for publishers to evaluate. My experience raised a number of questions that I have outlined below. These questions range from personnel motivation to future trends in computing. I have gathered a panel of respected authors. I have asked each to respond to some of these questions. Time will also be available for the audience to ask questions and share their own experiences.
Polymorphic panelists
Authors: Becker Byron Weber , Rasala Richard , Bergin Joseph , Shannon Christine , Wallingford Eugene
Published: July 2004

Polymorphism is an important object-oriented programming concept in which objects from two or more different classes respond to the same set of messages. For instance, HourlyEmployee, SalariedEmployee, and ContractEmployee all respond to the message calculatePay(). Instances of each class "do the right thing" to calculate their pay even though the methods to do so may be quite different. But the payroll program using these classes doesn't care - it can ask each object for the amount owed without caring what kind of employee it represents or how the amount is calculated.The panelists are all instances of subclasses of Professor which will respond to the following queries. Since each of the subclasses implement these queries differently, the answers will usually be different as well!• polymorphPreconditions(): The object (professor) specifies the information students must know before polymorphism is introduced in their class.• polymorphPresentation(): The object (professor) describes how polymorphism is introduced in their class.• polymorphStudentUsage(): The object (professor) describes how their students use polymorphism later in the course.• answerQuestions(): The object (professor) responds to any questions about their approach.
LR and LL parsing
Authors: Pijls Wim
Published: July 2004

The two best known parsing algorithms are LR and LL parsing respectively. These algorithms are explained extensively in the vast literature on compiler construction and formal language theory. In almost any textbook, LR and LL are regarded as two distinct methods. In this paper we will show that there exists a clear relationship between those methods, putting them into one framework. To our experience, such a framework is very useful from a didactic point of view. Moreover, the relationship between LR and LL provides a deeper insight into each separate method.
The role of scientific discovery in teaching and learning of computer science
Authors: Olagunju Amos O.
Published: July 2004

The importance of the roles of mathematics and engineering in the use of computers for solving real world problems cannot be over emphasized. This paper advocates the engagement of professors with diversified experiences of the applications of computers in the real world in teaching lower level computer science courses such as experiments designed to characterize Fibonacci and higher order similar sequences. With the goal of illustrating how scientific discovery experiments are designed, the paper shows certain connections between different areas of mathematics and computer science.
Using on-computer exams to ensure beginning students' programming competency
Authors: Jacobson Norman
Published: July 2004

The first programming course at UC Irvine has traditionally used graded programming assignments to assess students' programming competence and readiness to undertake the programming required in the next course. Problems with this approach led to replacing the assignments with on-computer programming exams. Several improvements in the course and its ability to reliably meet its goals have resulted.
Teaching COBOL in computer information systems programs
Authors: Uckan Yuksel
Published: July 2004

The COBOL component in four-year computer information systems programs is crucial to the rest of the program, and should be handled with special care. Particularly in CIS programs modeled after ACM's recommendations for computer information systems, students who have become reasonably proficient in a high level programming language find a course on introductory COBOL rather unmotivating. Furthermore, experience has shown that COBOL is not an ideal language as the first procedural language in CIS programs.It is our conviction that COBOL should be taught in CIS programs as a file processing language, using a data structures approach, as suggested by the ACM's IS2 component. In this paper, we propose a course description and topics sequence, and describe an implementation experiment based on the proposal. Following a brief survey of the elementary features of the language, the proposed course has aimed to teach advanced COBOL features, data and file structures, and fundamental concepts of software engineering in an integrated fashion. The experiment has been highly successful, and the course has been incorporated in our CIS curriculum at Miami University, Systems Analysis Department.
Increasing the confidence in off-the-shelf components
Authors: Rakic Marija , Medvidovic Nenad
Published: July 2004

The promise of component-based software development is that larger, more complex systems can be built reasonably quickly and reliably from pre-fabricated (“ off-the-shelf”) building blocks. Additionally, such systems can be upgraded incrementally, simply by replacing individual components with their new versions. However, practice has shown that while it may improve certain aspects of an existing component, a new component version frequently introduces unforeseen problems. These problems include less efficient utilization of system resources, errors in the newly introduced functionality, and even new errors in the functionality carried over from the old version. This paper presents an approach intended to alleviate such problems. Our approach is based on explicit software architectures and leverages flexible software connectors in ensuring that component versions can be added and removed in the deployed, running system. Our connectors, called multi-versioning connectors, also unintrusively collect and compare the execution statistics of the running component versions (e.g., execution time and results of invocations). We illustrate our approach with the help of an example application.
Producing reusable object-oriented components
Authors: Price Margaretha W. , Needham Donald M. , Demurjian Steven A.
Published: July 2004

Developing reusable object-oriented software requires a designer to determine how to structure a software system so as to achieve the necessary functionality, while at the same time increasing the reuse potential of the software. We introduce a set of reusability metrics intended to be iteratively applied during the design and implementation parts of the software life-cycle to help guide the production and identification of reusable components. Component identification centers on the application's domain, with reuse focusing specifically on an organization's future systems. Our approach requires the developer to subjectively categorize classes, identify component boundaries, and specify where components are related. Our metrics provide reuse valuations on the couplings between components. Based upon the results of applying our metrics, we provide refactoring guidelines to increase the separation between components in a manner that improves component reusability. We include an application of our metrics to a commercial objec-oriented framework.
Generation of visitor components that implement program transformations
Authors: Stirewalt R. E. Kurt , Dillon Laura K.
Published: July 2004

The visitor pattern is appealing to developers of program-analysis tools because it separates the design of the data structures that represent a program from the design of software that traverses these structures. Unfortunately, the visitor pattern is difficult to apply when the analysis involves transformation logic that involves multiple program fragments simultaneously. We encountered this problem in our work on the {\proj} project and discovered a novel way to use multiple cooperating visitor objects to systematically implement such functions when they are specified via a set of transformation rules. This paper introduces our {\em curried-visitor framework} and illustrates how we applied it to implement a key component in the {\proj} framework. We are working on a code generator that will automatically synthesize curried-visitor frameworks from a description of a program's abstract syntax and a set of pattern-matching transformation rules.
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.
Using partial order techniques to improve performance of data flow analysis based verification
Authors: Naumovich Gleb , Clarke Lori A. , Cobleigh Jamieson M.
Published: July 2004

Partial order optimization techniques for distributed systems improve the performance of finite state verification approaches by avoiding redundant exploration of some portions of the state space. Previously, such techniques have been applied in the context of model checking approaches. In this paper we propose a partial order optimization of the program model used by FLAVERS, a data flow based finite state verification approach for checking user-specified properties of distributed software. We demonstrate experimentally that this optimization often leads to significant reductions in the run time of the analysis algorithm of FLAVERS. On average, for those cases where this optimization could be applied, we observed a speedup of 21%. For one of the cases, the optimization resulted in an analysis speedup of 91%.
New type signatures for legacy Fortran subroutines
Authors: Preston Nicky Williams
Published: July 2004

We are currently developing a methodological framework for reverse engineering Fortran77 programs used by Electricité de France, in which the first step is the construction of an algebraic specification which faithfully represents the Fortran code. To construct this specification, we must decide on a coherent set of "profiles" (type signatures) for the specifications of the Fortran sub-programs. We propose an analysis of the dynamic aliases between formal and actual sub-program arguments in order to derive these profiles. In many examples of real Fortran code this analysis does not give satisfactory results if arrays are treated as indivisible. Instead, we must take into account which fragment of the array may really be accessed by the sub-program. We have therefore implemented our analysis as an extension of the
PIPS
code parallelisation tool, which provides us with a precise analysis of inter-procedural array data-flow.
Fifth California software symposium
Authors: Garg Pankaj K. , Sankar Sriram
Published: July 2004

The California Software Symposium (CSS), which was held this year on March 30 at the University of California, Irvine, is the fifth in a series of symposia held annually in southern California. Previously, it was called the Irvine Software Symposium, and was organized by the University of California, Irvine. Starting this year, the event is co-organized by University of California, Irvine; and University of Southern California, Los Angeles (hence the name change). The symposium will be located alternately at the two organizing sites---the next will be at the University of Southern California in April 1996.The purpose of this symposium is to bring together researchers and practitioners to share ideas and experiences in areas of software engineering. This year, a successful tools fair organized by IRUS (Irvine Research Unit in Software) was co-located with the symposium. The participating vendors were: Atria, Cadre, Continuus, IDE, Intersolv, Mark V, Rational, Softool, and Sun.The symposium is slowly gaining momentum and there has been a noticeable increase in the number of papers submitted and in participation. We anticipate further growth in the coming years.The symposium was co-chaired this year by Barry Boehm (USC), and Debra Richardson (UCI). The program committee consisted of 22 people, with a good mixture of academic and industrial representatives.For further information on the upcoming CSS or for any other related information, please contact Debra Brodbeck (714-824-2260, brodbeck@ics.uci.edu) or Sandra Lapis (213-740-5703, sandra@sunset.usc.edu).
Internet agility/Maturity model survey for the software industry call for participation
Authors: Bruce Michael
Published: July 2004

This project is the first phase of M.S. thesis research performed by Michael Bruce, a graduate student at the Information Networking Institute of Carnegie Mellon University. This work is being done in conjunction with INSTEP, Inc., a strategic development firm located in Northern Virginia.The goal of the thesis is to evaluate the Internet's pervasiveness in the software industry, while creating a framework which enables a software firm to strategically and successfully increase its Internet presence. Towards this end, we are distributing a questionnaire entitled the Internet Agility/Maturity Model Survey for the Software Industry.The Internet Agility/Maturity Model (IAMM) survey elicits Internet usage trends with the software industry in each of the following five areas:• Background Information on Corporate Internet Use: Queries regarding the initial Internet connectivity planning and establishment phases.• Internet Presence Management: Queries regarding resources committed to on- going support and administration of the corporation's Internet presence• Internet ROI / Business Process Integration: Queries regarding which functions use Internet services, the tools employed to do so, and the value of an organization's presence in terms of its ROI• Internet Utilization Issues: Queries regarding future issues and current difficulties pertaining to the corporation's Internet presence• Agile Competitors and Virtual Organizations: Queries regarding the knowledge of and the concepts incorporated into the Iacocca Institute's agility modelA summary of our findings will be submitted for publication in a future issue of Software Engineering Notes.
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.
Advanced structured COBOL programming
Authors: Khailany Asad
Published: July 2004

There is a large market demand for COBOL programmers. Can a single introductory course in COBOL programming provide the students with sufficient professional expertise to qualify them for these job openings? If not, is it feasible to offer a second course in COBOL programming? In this paper the technical capabilities of those who have completed an introductory COBOL programming course and the skills and technical qualifications which are desired by employers of entry level COBOL programmers are analyzed. It is concluded that a single introductory COBOL programming course is not sufficient to produce COBOL programmes with the qualifications and skills expected by employers. Therefore, an advanced structured COBOL programming course is proposed. The goals and the course outline including texts and references of such an advanced course are presented. Several samples of integrated information systems which have been completed by student teams in Advanced Structured COBOL programming will be available for the audience.
A multiprogramming operating system for a minicomputer
Authors: Weymouth Terry E. , Perry James T.
Published: July 2004

Described in this paper is a small, modular operating system which was written for an Interdata-70 machine. The total operating system is memory resident and occupies 5K bytes. The primary motivation in redesigning the operating system was to structure it so that students and general system users could easily expand or modify the basic services of the supervising system. Towards this end, the following system principles are embodied in the design: (1) clearly defined separation of system functions, (2) separate object modules for each system routine, and (3) simple system design. Although specifics of implementation are discussed, general design concepts are covered which should aid the reader in any similar attempt (either by example or counter example).
A top-down, laboratory based operating system course
Authors: Grit Dale H. , Georg Dennis D.
Published: July 2004

An operating system course is described which is organized in a top-down fashion and strongly emphasizes the concept of “learning by doing.” The course content and the corresponding laboratory assignments are discussed. The suggested modularization of the laboratory provides substantial flexibility for course emphasis.
Calculator metaphors, and goals for calculator education in elementary schools
Authors: Moursund David
Published: July 2004

Computers are not easy to understand. Even a computer scientist who devotes full time to the field cannot hope to fully comprehend the capabilities, limitations, applications, and implications of these machines. Joseph Weizenbaum, in his recent book
Computer Power and Human Reason
(1), suggests that most people “understand” computers via what he calls a computer metaphor. Weizenbaum quotes I. A. Richards, who says a metaphor is “fundamentally a borrowing between and intercourse of thoughts, a transaction between contexts.” That is, a metaphor is an analogy, a simile, a model; it is designed to relate the unknown to the known.

There are many possible computer metaphors. Weizenbaum makes the point that many people have accepted one particular computer metaphor, and that it is a particularly misleading one. Computer scientists think of a computer as a machine that can carry out an effective procedure. The words procedure and effective procedure have meaning to non-computer scientists. They can see that humans carry out procedures, or that many activities of humans can be thought of as execution of effective procedures. The effective procedure computer metaphor thus leads to the belief that humans and computers are quite similar in their capabilities and in the way they solve problems.
Problem formulation for programmers
Authors: Martin Edith W. , Badre Albert N.
Published: July 2004

The various attempts to augment man's information processing capabilities with the use of machines became significantly more realistic with the advent of the modern electronic and adaptive-logic computers

4

. With the introduction of advanced computing capabilities, a host of new and serious challenges emerged. One of the main challenges is that of transforming an ill-stated problem to one acceptable by the computer. Once a problem is well-stated, communication becomes relatively simple

3

. The burden is on the programmer to be the interface between the world of ill-stated problems and the computers. The programmer has to select a methodology by which he can take an ill-stated problem and restate it in such a way that it can be developed into a set of procedures and expressed in a language that is acceptable and understood by the machine. In order to more fully utilize computers for problem solving it is necessary that we understand more completely how we formulate a problem solution. Probes into the problem formulation question have been of two types, symptomatic and methodilogical. The symptomatic approach focuses on the program structuring capabilities provided by programming languages. It is believed that programming languages having certain program structuring features permit a more comprehensible organization of the problem solution and relate positively to successful programming. The second approach, which is being proposed here, is to examine problem solving methodologies used in computer programming. Our specific objectives are (1) to examine the possibility that a recognizable set of problem solving strategies maybe observed in a programming task, (2) given such strategies, the relationship these have to success levels in programming performance. In other words, how does programming performance vary as a function of the structuring of the problem by the programmer.
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.
Approaches to based storage in PL/I
Authors: Augenstein Moshe , Tenenbaum Aaron
Published: July 2004

In this paper it is shown how the topic of BASED storage in PL/I can be used to illustrate a wide variety of concepts in intermediate level courses in data structures and programming languages. Because most instructors introduce the topic only from the point of view of a linked list, the true meaning of BASED storage and POINTERs is lost in the maze of practical problems which these features can be used to solve. Because BASED storage allows the programmer close access to physical storage, an understanding of these features goes a long way toward clarifying the behind the scenes actions involved in implementing and using data structures in high level languages.
Macrognosographics
Authors: Brewer Richard K.
Published: July 2004

Several rationales for flowcharting computer programs are discussed along with weaknesses, strengths, and current trends. One often over-looked motivation is the use of “macro-flowcharts” to compare, for pedagogical reasons, the gross features of various classes of processes involved in applied programs. The techniques and virtues of this approach are the focus of the paper.
Turning on the undergraduate computer science student
Authors: Schulman Edward L.
Published: July 2004

The School of Advanced Technology currently has a number of courses that are used to better acclimate students on the graduate level to an industrial environment. This paper describes a two-course sequence designed for the
undergraduate
level that serves the same purpose.
Developing computer awareness
Authors: Mazlack Lawrence J.
Published: July 2004

There are three different approaches to an introductory computer science course: technical competance, non-technical awareness, and a mixture of technical competance and non-technical awareness. This paper discusses the best strategy for a course aimed at students who will not need a high level of technical competance once they leave the course. A course which develops a computer awareness through a mixture of technical programming instruction and a discussion of computer applications and power for good or evil. Films are extensively used.
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).
An approach to the introductory computer science course for non-majors
Authors: Cook Robert N.
Published: July 2004

The course described in this paper is intended for students who are not majoring in computer science or mathematics. In a typical semester students majoring in such diverse fields as dietetics, sociology, psychology, elementary education, accounting, broadcasting, physical education, music, industrial technology, english, business administration, chemistry and secretarial science are enrolled in the course. Virtually the only common element in the background of the students enrolled in the course is their lack of a previous university course in either mathematics or computer science. The highest level of mathematical education that may be expected is first year high school algebra; occasionally even that expectation is too high.
4
For students with this background many of the available textbooks are not satisfactory. This paper will attempt to further clarify the nature of the course by stating its objectives, by discussing the choice of a language for the course, by discussing what topics normally included in available textbooks are not desirable, and finally by suggesting topics which are desirable in an introductory course for non majors.
An introductory computer science course for all majors
Authors: Gibbs Norman E.
Published: July 2004

The purpose of this paper is to relate experience we have had with our first course in computer science at the College of William and Mary. Like many other universities, we have had to deal with increased student demand from outside departments, differing levels of student mathematical maturity and problem solving skills, a variety of student goals, and a state legislature which will not allow the university to expand its faculty.
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.
The design and implementation of a dynamically tailored examination
Authors: Whitlock Lawrence R.
Published: July 2004

Traditionally, examinations have served as evaluation tools for the instructor to aid in assigning grades and to detect concepts not yet mastered by students.

Questions requiring more information in the response than just a single word or number can give a better indication of the student's knowledge of the concepts being tested.

This type of question is more difficult to grade because the correct answer is not a single word or number, there may be more than one correct answer, or some responses may deserve partial credit. Hand grading of such questions is often inconsistent and laborious. Automatic grading systems have been developed which score responses to complicated problems and analyze student deficiences (e.g., [2], [3]), but these methods may be too time-consuming for use in an interactive environment.

An alternate approach to complex grading is to adapt the problems to the abilities of the student. An oral exam is an example of this approach.

This paper discusses some problems and solutions of administering an “oral exam” via a computer. Such an exam will be referred to as a “tailored exam”. The tailored exam extends to examinations some of the ideas used in individualized instruction in Computer Assisted Instruction.
The near blind leading the blind
Authors: Hardell Mary M.
Published: July 2004

This paper reports on an experimental course taught by the author at Worcester Polytechnic Institute. The motivation for the unusual structure of the course was to bolster student morale weakened by inadequate background. Students, whose performance in a course had been only average, were given academic credit for tutoring students in a trailing lectureless section. Student response was overwhelmingly favorable and academic results appear to be at least as good as under more traditional course structures.
Whither flowcharting?
Authors: Hosch Frederick A.
Published: July 2004

During the past few years, a growing number of authors have begun to take exception to the previously unquestioned use of flowcharts as a program development tool. These criticisms of the traditional flowcharting methodology center around the claim that flowcharts, like
goto's
, belong to the class of objects that are detrimental to good programming. Suggested alternatives range from developing programs entirely in well-structured high level languages to replacing conventional flowcharts by some form of “structured” flowcharts.

We are particularly concerned with questions that have been raised regarding the value of flowcharting in introductory programming classes.

The teaching of flowcharting as a developmental tool is extremely widespread indeed.

While the various methods of indicating data flow, document flow, etc., are certainly an important part of program development and documentation, we consider here only conventional “flow of control” flowcharts.
Standards considered helpful
Authors: Guha R. K. , Carr P. A. , Smith C. L.
Published: July 2004

Software development standards have been adopted in several professional software shops to facilitate the entire software development process. These standards encompass all aspects of software development, including design, documentation, coding and testing techniques. It has been reported by these software houses that implementation of standards for software design and programming has increased productivity and resulted in better quality software products

After some experimentation, it appears that a scientific approach from the very beginning to the end of the development process has to be taken. Instructors should work very closely with the students as each phase of the process is developed. Courses should be integrated so that the life of a program does not end as soon as a course is over. Maybe programs written in one course should be used in developing programs in another course. Perhaps there should be users (such as another class) for the programs developed. For our scientific approach to software development in the academic setting, we are advocating a consistent set of standards and its implementation by every faculty member. In the rest of the paper we justify the need for standards, specify the types of standards and suggest methods of implementation.
Applications programming course using guided design
Authors: Cook Curtis R.
Published: July 2004

This paper describes a two term junior level Applications Programming course. The goal of the course is to provide the guidance and tools a student needs in order to write medium to large sized programs and to provide the experience of working on a “real world” project. Topics covered during the first term are documentation, magnetic tapes, program design, testing, debugging and programming style. The second term consists entirely of student teams doing “real world” projects applying the concepts from the first team.

Much of the first term material was presented in the form of Guided Design exercises. In Guided Design, the learning process revolves around student groups being directed towards a problem solution by a series of instruction-feedback materials prepared ahead of time by the instructor. Guided Design exercises were used to synthesize lecture and reading assignments and to do in class example programs.
MUSIC
Authors: Carpenter B. E. , Jenkins P. C. , Pearson L. W. , Thomas L. K.
Published: July 2004

MUSIC (Massey University simple Instructional Computer) was designed
to fit into a university computer science course and nevertheless to remain realistic. It is a one-address machine with a byte-addressed virtual memory and a fixed format macro-assembly language, and is implemented as an assembler and emulator running on a Burroughs B6700. It has been used very successfully as a teaching tool for two years, notably because of its straightforward design and the provision of excellent error messages.
Teaching disciplined Fortran programming via unfort
Authors: Embley David W.
Published: July 2004

This short note describes UNFORT (University of Nebraska FORTRAN),
briefly mentions howit is used in teaching disciplined FORTRAN programming, and announces that a portable UNFORT perprocessor is available.