bluuebunny/crossref_metadata_2025_split huggingface dataset:
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.
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.
Computer-Aided Software Engineering in a distributed workstation environment
Authors: Leblang David B. , Chase Robert P. 
Published: July 2004

Computer-Aided Software Engineering environments are becoming essential for complex software projects, just as CAD systems have become essential for complex hardware projects. DSEE, the DOMAIN Software Engineering Environment, is a distributed, production quality, software development environment that runs on Apollo workstations. DSEE provides source code control, configuration management, release control, advice management, task management, and user-defined dependency tracking with automatic notification.
DSEE incorporates some of the best ideas from existing systems. This paper describes DSEE, contrasts it other systems, and discusses some of the technical issues involved in the construction of a highly-reliable, safe, efficient, and distributed development environment.
Document structure and modularity in mentor
Authors: Donzeau-Gouge V. , Kahn G. , Lang B. , Mélèse B. 
Published: July 2004

Mentor is a structured document manipulation system. It has been used for several years as a program development and maintenance environment.
Its main characteristics are:
it is both interactive and programmable,
it is parameterized by the language to be manipulated,
it can manipulate several languages at the same time, as well as multi-lingual documents.
it is open to and from the outer system,
it is extensible.
The current development of Mentor reflects our belief that a major component of programming is the maintenance of large documents of a varied nature: specifications, programs, manuals, progress reports, documentation, etc... In addition, information of various kinds, and in different languages, is often mixed in a single document, and one may have to extract this information selectively upon request (e.g. text, examples and formal specification in a manual, or instructions, comments and assertions in a program).
Preliminary experience with a configuration control system for modular programs
Authors: Estublier J. , Ghoul S. , Krakowiak S. 
Published: July 2004

This paper describes some preliminary experience gathered during the implementation and early use of a program composition and version control system. This system has been designed and implemented as a part of the Adele research project, a programming environment for the production of modular programs (Estublier 83). This project has four main components: a) a program editor, interpreter and debugger; b) a parameterized code generator; c) a user interface; d) a program base, the subject of this paper. The current version of this environment has been developed on a Multics system.
The program base, including the system composition and version control mechanisms, has been used for six months, notably for its own development and maintenance.
Restricted data types, specification and enforcement of invariant properties of variables
Authors: Buckle Normand 
Published: July 2004

When defining a data type, it is often useful to specify restrictions on the permitted values of that type.
Pascal's subrange type declaration, a special case of this kind of constraint definition, has already proved itself to be quite useful. Restricted data types allow more complex constraints to be defined and checked; for example, a variable could be declared of type “odd integer” or the day field of a “date” type variable could be checked for consistency with the year and month fields.
A simple mechanism is proposed, allowing the formulation of such constraints and their association with data types; the behaviour of a restricted type variable is described. The effects of the use of such a mechanism on program reliability, readability and efficiency are discussed.
An experimental investigation of the effect of program structure on program understanding
Authors: Love Tom 
Published: July 2004

A within-subjects experimental design was used to test the effect of two variables on program understanding. The independent variables were complexity of control flow and paragraphing of the source code. Understanding was measured by having the subjects memorize the code for a fixed time and reconstruct the code verbatim. Also some subjects were asked to describe the function of the program after completing their reconstruction. The two groups of subjects for the experiment were students from an introductory programming class and from a graduate class in programming languages.
The major findings were that paragraphing of the source had no effect for either group of subjects but that programs with simplified control flow were easier for the computer science students to understand as measured by their ability to reconstruct the programs. The dependent variable, rated accuracy of their description of the programs functions, did not differ as a function of either independent variable.
The paper is concluded with a description of the utility of this experimental approach relative to improving the reliability of software and a discussion of the importance of these findings.
Abstraction mechanisms in CLU
Authors: Liskov Barbara , Snyder Alan , Atkinson Russell , Schaffert Craig 
Published: July 2004

CLU is a new programming language designed to support the use of abstractions in program construction. Work in programming methodology has led to the realization that three kinds of abstractions, procedural, control, and especially data abstractions, are useful in the programming process. Of these, only the procedural abstraction is supported well by conventional languages, through the procedure or subroutine. CLU provides, in addition to procedures, novel linguistic mechanisms that support the use of data and control abstractions.
This paper provides an introduction to the abstraction mechanisms in CLU. By means of programming examples, we illustrate the utility of the three kinds of abstractions in program construction and show how CLU programs may be written to use and implement abstractions. We also discuss the CLU library, which permits incremental program development with complete type-checking performed at compile-time.
Robots in the laboratory
Authors: Atkins Stella , Hafer Lou , Leung Patrick 
Published: July 2004

A $70 toy robot has been successfully used in Computer Science undergraduate laboratory courses in real-time programming and advanced operating systems to provide students with hands on experience.
A custom designed interface card connects a Radio Shack Armatron toy mobile robot with an IBM PC. To provide sensory input and hence introduce feedback, the robot is shackled to a track filled with sensors. Extra sensors in the robot's environment allow challenging experiments such as picking up an object from a moving belt.
While programming the robot and its environment in Turbo Pascal, the students learn how to write software drivers to control low level hardware that requires real-time response. This experimental design obviates the need to use sophisticated test equipment or special software development tools, and so the robot has transformed potentially routine courses into a exciting and fulfilling learning experiences.
Proposed criteria for accreditation of computer information systems programs
Authors: Cannon Robert , Gorgone John , Ho Tom , McGregor John D. 
Published: July 2004

A working group, representing ACM, DPMA, and IEEE-CS, was formed to draft a set of guidelines, including criteria, for the accreditation of computer information systems' undergraduate programs. The guidelines and criteria are summarized below.
Faculty: Typically a minimum of 4 faculty, with 3 full time, are needed. Normally, 25% of a faculty member's time should be available for scholarly activity and development. Teaching loads should not exceed 12 hours and should not exceed 4 courses with 2 preparations.
Curriculum: Curricular assume a 120 semester hour, four year, baccalaureate program. The program should consist of approximately 30% computer information systems, 20% business, at least 40% in general education and up to 10% other.
Forty to 60 percent of the CIS portion should cover a broad core that includes a) computer concepts and software systems, b) program, data, and file structures, c) data management,
d) data and computer communications, and e) systems analysis and design. Students should be exposed to a variety of programming languages and be proficient in one structured language. The remaining courses should cover breadth and depth.
Resources: Appropriate computing facilities must exist for students and faculty. Adequate software and documentation must be available.
Students: Established standards and procedures must insure that graduates have the requisite qualifications to function as CIS professionals.
Institutional Support: Adequate support must be provided to support the faculty, department office administration, and library. Faculty support includes leave programs, reasonable teaching loads, competitive salaries, and travel support.
A student system development diagrammer
Authors: Hirmanpour Iraj 
Published: July 2004

New approaches to system development depend heavily on graphical methods for representation of system requirements and the depiction of final design configuration. Among various diagramming methods, Data Flow Diagrams, Entity-Relationship diagrams and Structure Charts have received the most attention.
An automated diagramming tool is created and is made available to students. This tool requires minimum hardware and does not require the use of licensed software to operate. It therefore can be made accessible to many students at different schools.
A design tool used to quantitatively evaluate student projects
Authors: Selig Calvin , Henry Sallie 
Published: July 2004

In the last decade, the field of Computer Science has undergone a revolution. It has started the move from a mysterious art form to a detailed science. The vehicle for this progress has been the rising popularity of the field of Software Engineering. This innovative area of computer science has brought about a number of changes in the way we think of, and work with, the development of software. Due to this renovation, a field that started with little or no design techniques and unstructured, unreliable software has progressed to a point where a plethora of techniques exist to improve the quality of a program design as well as that of the resultant software. The popularity of structured design and coding techniques prove that there is widespread belief that the overall product produced using these ideas is somehow better, and statistics seem to indicate that this belief is true. Until recently, however, there existed no technique for quantitatively showing one program better than its functional equivalent. In the past few years, the use of software quality metrics seems to indicate that such a comparison is not only possible, but is also valid.
The advent of Software Engineering has demanded that most universities offer a Software Engineering course which entails a “Real-World” group project. Students participating in the class design a system using a program design language (PDL). Other students then write code from the design and finally the design team integrates the modules into a working system. For a complete description of the class see [HENS83] and [TOMJ87].
Introducing finite automata in the first course
Authors: Headington Mark R. 
Published: July 2004

In the computer science curriculum, finite state machines and finite automata are typically introduced at the upper-division level. However, students can benefit from an earlier, informal exposure to finite automata for three reasons:
- Finite automata represent a useful application when two-dimensional arrays are introduced.
- A painless early introduction can ease the transition to rigorous approaches encountered later.
- Finite automata provide yet another algorithmic tool to be added to the student's repertoire.
An industry/academic partnership experiment: a course in artificial intelligence
Authors: Little Joyce Currie , Cooper Laurence J. , Davis Barry C. , Alexander John , Joyce Peter , Schmitt Charles J. 
Published: July 2004

This paper describes an experimental undergraduate course in applications of artificial intelligence, sponsored by an Industry/Academic Partnership with Towson State University. The course was developed as one of several activities promoting interaction between faculty, students, and industry in the local metropolitan area.
Towson State University is located in the metropolitan Baltimore, Maryland area, in close proximity to many companies involved in technological projects related to defense, automation, and aerospace endeavors. Three companies provided projects, leadership, and support to the course. The three projects were expert systems in the area of electronic diagnostics.
This paper describes the course; the diagnostic systems projects done by the student teams; and the activities of students, faculty, and industry liaisons. An evaluation of the course included meetings with industry liaisons and faculty and a follow-up survey of the students. Consideration of prerequisites for improvement of the course led to discussions of overall curriculum revision. Suggestions for ways to improve the course are given.
Departments interested in offering similar artificial intelligence project courses with industry participation may benefit from these experiences and recommendations.
IBM 3270 full screen interactive programming without CICS
Authors: Chen Hilton , Summers Wayne 
Published: July 2004

During the past several decades, full screen interactive programming has become essential in data processing. However, it is impossible or difficult to teach full screen interactive programs on IBM mainframes at universities because of the enormous cost of CICS and the lack of flexibility with the MUSIC PANEL utility. This article describes our solution to the need described in [4] for an inexpensive utility which will allow COBOL programmers to do interactive programming on mainframes utilizing full screen techniques.
At Southeast Missouri State University, we have addressed these problems with a utility program which facilitate full screen interactive programming. This program has been developed by Dr. Hilton C. Chen with comments and suggestions by Dr. Wayne C. Summers. The utility program is friendlier and easier to use and considerably more useful than MUSIC's PANEL. More importantly, it gives our students experience in full screen interactive programming on mainframes.
The impact of menus and command-level feedback on learners' acquisition of data base language skills
Authors: Sumner Mary , Benjamin James 
Published: July 2004

The purpose of this study was to determine whether providing menus and postactive feedback of command-level syntax can facilitate the acquisition of formal language skills by novice learners. Two groups of students, one of which received training in a menu version of dBASE III Plus and the other of which received instruction in a command version, were asked to complete data base file maintenance and query tasks. Measures comparing the performance of the two groups on a post-test were completion of tasks, number of syntactical errors, and number of semantic errors.
According to the results, students learning the command version of dBASE III Plus were able to accomplish more tasks successfully than students using the menu version with postactive feedback of command syntax. In addition, the group using the menu driven made more syntactic errors than the group using the command version. The difference between the number of semantic errors made by members of the two groups was not significant. The researchers made several recommendations for instruction and for further research.
Should computer science examinations contain “programming” problems?
Authors: Bagert Donald J. 
Published: July 2004

The purpose of many computer science courses is to enhance the programming skills of the student, including the ability to design and implement appropriate algorithms. In such courses, examinations should therefore contain problems which test for algorithmic skills. In particular, there should be problems which require the student to write small sections of code, usually in the form of a subprogram. Students often perceive these questions as “programming” problems; however, it is more accurate to state that these are algorithmic problems, since such questions primarily measure algorithmic skills. In addition, since such exam problems address topics which are a part of the course content (e.g. stacks, queues, and tables in a data structures class), the student's knowledge of these topics is also tested and reinforced.
This paper discusses how examination questions which test algorithmic skills have been implemented in a data structures course at Northeast Louisiana University. Arguments both for and against using such test questions are discussed, as well as the proper format and amount of this type of problem. The results of a survey of data structures students at Northeast concerning this topic is also presented.
There has been relatively little discussion on the topic of computer science examinations in the literature. It is hoped that the publication and presentation of this paper will stimulate dialogue in this area among academicians.
Pgraphite: an experiment in persistent typed object management
Authors: Wileden Jack C. , Wolf Alexander L. , Fisher Charles D. , Tarr Peri L. 
Published: July 2004

Defining, creating, and manipulating
persistent typed objects
will be central activities in future software environments. PGRAPHITE is a working prototype through which we are exploring the requirements for the persistent object capability of an object management system in the Arcadia software environment.

PGRAPHITE represents both a set of abstractions that define a model for dealing with persistent objects in an environment and a set of implementation strategies for realizing that model. PGRAPHITE currently provides a type definition mechanism for one important class of types, namely directed graphs, and the automatic generation of Ada implementations for the defined types, including their persistence capabilities.
We present PGRAPHITE, describe and motivate its model of persistence, outline the implementation strategies that it embodies, and discuss some of our experience with the current version of the system.
Low-cost networks and gateways for teaching data communications
Authors: Hughes Larry 
Published: July 2004

The growing importance of communications in computer science has resulted in many undergraduate computer science programmes offering courses in data communications. Although data communications courses can be taught in a practical manner, the cost of data communications hardware often restricts the amount of actual hands-on experience that students can gain.
In this paper we describe the hardware and software requirements of several low-cost networks that can be used by students to gain experience in a wide variety of data communication topics including local area networks (such as bus networks and ring networks), wide area networks (i.e. store-and-forward networks), and gateways.