bluuebunny/crossref_metadata_2025 huggingface dataset:
Is computer technology taught upside down?
Authors: Maj S. P. , Veal D. , Charlesworth P.
Published: July 2004

There has been a continuing fragmentation of traditional computer science into other disciplines such as Multimedia, e-commerce, software engineering etc. In this context the standard computer technology curriculum designed for computer science students is in danger of becoming perceived as increasingly irrelevant --- both by students and employers. The authors review expectations of both students and employers, as determined by market analysis, and present the results of implementing one possible solution to providing an introductory computer technology curriculum suitable not only for students from other disciplines but also as a basis for Computer Science majors.
A semi-automated approach to online assessment
Authors: Jackson David
Published: July 2004

Desirable though fully automated assessment of student programming assignments is, it is an area that is beset by difficulties. While it is not contested that some aspects of assessment can be performed much more efficiently and accurately by computer, there are many others that still require human involvement. We have therefore designed a system that combines the strengths of the two approaches, the assessment software calling upon the skills of the human tutor where necessary to make sensible judgements. The technique has been used successfully on a systems programming course for several years, and student feedback has been supportive.
A methodology for teaching object-oriented programming concepts in an advanced programming course
Authors: Arif Essam M.
Published: July 2004

I have been teaching an advanced programming course for undergraduate students for four years. My intention is that object-oriented programming principles and concepts could be easily simplified and taught to the students in this course. In this paper we will discusses a step by step methodology that I use in this course to teach my students how to understand and apply these concepts. The paper also attempts to determine the attribute of students to OOP and their reaction towards the methodology. It reports the result of a survey conducted to students after taking two introductory computer programming courses using a structural programming language.
Impact of computing platforms on the performance of the asymmetric traveling salesman problem
Authors: Soklic Milan E.
Published: July 2004

This article discusses a serial and a parallel version of a heuristic algorithm for a solution to the traveling salesman problem, implementation of these algorithms, and their performance in terms of finding the most favorable solution, and an average solution. The algorithms implemented in C sequential programming language, and in Occam concurrent programming language were run on different computing platforms to study their impact on the comparative value of the solutions each platform provided. The programs were tested on reference data from TSPLIB data files, a collection of sample instances of traveling salesman problem. Experimental results, using asymmetric cost matrix, indicate good performance compared to the optimal solutions provided in the TSPLIB reference library.
Experience report
Authors: Hollingsworth Joseph E. , Blankenship Lori , Weide Bruce W.
Published: July 2004

Academic research sometimes suffers from the “ivory tower” problem: ideas that sound good in theory do not necessarily work well in practice. An example of research that potentially could impact practice over the next few years is a novel set of component-based software engineering design principles, known as the
RESOLVE discipline
. This discipline has been taught to students for several years [23], and previous papers (e.g., [24]) have reported on student-sized software projects constructed using it. Here, we report on a substantial commercial product family that was engineered using the same principles — an application that we designed, built, and continue to maintain for profit, not as part of a research project. We discuss the impact of adhering to a very prescriptive set of design principles and explain our experience with the resulting applications. Lessons learned should benefit others who might be considering adopting such a component-based software engineering discipline in the future.
Extracting library-based object-oriented applications
Authors: Sweeney Peter F. , Tip Frank
Published: July 2004

In an increasingly popular model of software distribution, software is developed in one computing environment and deployed in other environments by transfer over the internet. Extraction tools perform a static whole-program analysis to determine unused functionality in applications in order to reduce the time required to download applications. We have identified a number of scenarios where extraction tools require information beyond what can be inferred through static analysis: software distributions other than complete applications, the use of reflection, and situations where an application uses separately developed class libraries. This paper explores these issues, and introduces a modular specification language for expressing the information required for extraction. We implemented this language in the context of
Jax
, an industrial-strength application extractor for Java, and present a small case study in which different extraction scenarios are applied to a commercially available library-based application.
Composing features and resolving interactions
Authors: Hay Jonathan D. , Atlee Joanne M.
Published: July 2004

One of the accepted techniques for developing and maintaining feature-rich applications is to treat each feature as a separate concern. However, most features are not separate concerns because they override and extend the same basic service. That is, “independent” features are coupled to one another through the system's basic service. As a result, seemingly unrelated features subtly interfere with each other when trying to override the system behaviour in different directions. The problem is how to coordinate features' access to the service's shared variables.

This paper proposes coordinating features via feature composition. We model each feature as a separate labelled-transition system and define a
1conflict-free (CF) composition
operator that prevents enabled transitions from synchronizing if they interact: if several features' transitions are simultaneously enabled but have conflicting actions, a non-conflicting subset of the enabled transitions are synchronized in the composition. We also define a
conflict- and violation-free (CVF) composition
operator that prevents enabled transitions from executing if they violate features' invariants. Both composition operators use priorities among features to decide whether to synchronize transitions.
COM revisited
Authors: Jackson Daniel , Sullivan Kevin
Published: July 2004

Designing architectural frameworks without the aid of formal modeling is error prone. But, unless supported by analysis, formal modeling is prone to its own class of errors, in which formal statements fail to match the designer's intent. A fully automatic analysis tool can rapidly expose such errors, and can make the process of constructing and refining a formal model more effective.

This paper describes a case study in which we recast a model of Microsoft COM's query interface and aggregation mechanism into Alloy, a lightweight notation for describing structures. We used Alloy's analyzer to simulate the specification, to check properties and to evaluate changes. This allowed us to manipulate our model more quickly and with far greater confidence than would otherwise have been possible, resulting in a much simpler model and a better understanding of its key properties.
An alternative approach to recursive fibonacci sequences
Authors: Cox Michael
Published: July 2004

Generating a tera of a Fibonacci sequence is often discussed in introductory programming courses as an example where the recursive form has a very desirable simple beauty, but where the price of recursion is too high in terms of time and space. By generalizing to any Fibonacci sequence, another recursive formula can be used that saintains simple for a and understanding and yet is fast and requires reasonable resources.
Highly structured internship and cooperative education program in computer science
Authors: Ziegler William L.
Published: July 2004

Internships and Cooperative Education programs have existed in many fields for many years. One field that is yet to be dominated by programs of this type, is Computer Science. This paper will review the implementation of a very successful, competitively based, and highly structured Internship/Cooperative Education program. The advantages and disadvantages of such programs will be discussed, as well as the requirements that should be expected of students, industrial supervisors, and faculty supervisors. Results of research concerning the viability of such programs are also presented and analyzed.
A library to support a graphics-based object-first approach to CS 1
Authors: Bruce Kim B. , Danyluk Andrea , Murtagh Thomas
Published: July 2004

In this paper we describe a library we have developed that supports an "OO-from-the-beginning" approach to CS 1. The use of real graphics "objects" and event-driven programming are important components of our approach. The design of interactive graphical programs helps students to both use objects and write methods early while designing and implementing interesting programs.
Levels of exploration
Authors: Diehl Stephan , Kerren Andreas
Published: July 2004

Visualization of computational models is at the heart of educational software for computer science and related fields. In this paper we look at how generation of such visualizations and the visualization of the generation process itself increase exploration. Four approaches of increased exploration in formal language theory and compiler design are introduced and for each approach we discuss an educational system which implements it.
Teaching applied computing without programming
Authors: Marks Joe , Freeman William , Leitner Henry
Published: July 2004

We introduce general-education students to key ideas in applied computing through case studies from computer graphics, computer animation, image processing, computer vision, information retrieval, and artificial intelligence. Each case study consists of two lectures: one an intuitive exposition of relevant computer-science concepts, and the other a hands-on introduction to a working system that embodies these concepts. Students use these systems to perform design and problem-solving tasks, thereby reinforcing the abstract concepts presented. Computer programming is neither required nor taught. The course has been offered for two years at the Harvard University Extension School, and has achieved high ratings in student surveys.
Teaching networking and operating systems to information systems majors
Authors: Adams D. Robert , Erickson Carl
Published: July 2004

Teaching networking and operating systems to information systems majors presents many challenges. Operating systems and networking tend to be taught in one of two ways. Either the material is non-technical, directed more toward the
business
information systems major, or the material is overly technical, equivalent of teaching a traditional computer science course. We have developed a model for teaching networking and operating systems to information systems majors that bridges that gap. The material is taught in the context of network administration, a topic well-suited to information systems majors. This paper describes our model, the curriculum we use, and the experience of students and faculty.
Teaching design and project management with lego RCX robots
Authors: Wolz Ursula
Published: July 2004

In traditional CS 1 classes students may not develop an appreciation for the planning process in software development. Current IDEs provide such immediate feedback that students can complete courses without an appreciation for the need to plan in advance and design thoughtfully. The course unit described here took time out from a Java-based CS 1 course to give students practical experience in programming a small robot in a highly restricted setting. Outcomes are described in detail. They are based on instructor's notes, and on analysis of both videotaped student demonstrations and student summative essays.
Using lab practica to evaluate programming ability
Authors: Chamillard A. T. , Joiner Jay K.
Published: July 2004

One of the largest challenges facing educators teaching courses with a significant programming component is deciding how to evaluate each student's programming ability. In this paper we discuss how we have addressed this challenge in an introductory computer science course and statistically analyze the results to examine potential inequities in our approach.
An innovative design and studio-based CS degree
Authors: Docherty Michael , Sutton Peter , Brereton Margot , Kaplan Simon
Published: July 2004

The University of Queensland has recently established a new design-focused, studio-based computer science degree. The
Bachelor of Information Environments
degree augments the core courses from the University's standard CS degree with a stream of design courses and integrative studio-based projects undertaken every semester. The studio projects integrate and reinforce learning by requiring students to apply the knowledge and skills gained in other courses to open-ended real-world design projects. The studio model is based on the architectural studio and involves teamwork, collaborative learning, interactive problem solving, presentations and peer review. This paper describes the degree program, its curriculum and rationale, and reports on experiences in the first year of delivery.
Our curriculum has become math-phobic!
Authors: Tucker Allen B. , Kelemen Charles F. , Bruce Kim B.
Published: July 2004

The paper [2] argued that mathematical ideas play an important role in the computer science curriculum, and that Discrete Mathematics needs to be taught early in the computer science curriculum. In this follow-up paper, we present evidence that computer science curricula are drifting away from a fundamental commitment to theoretical and mathematical ideas. We propose some actions that can be taken to help reverse this drift.
Objectives and objective assessment in CS1
Authors: Lister Raymond
Published: July 2004

When designing a first semester "CS1" programming subject, I advocate "truth in sentencing". That is, the objectives should be explicit, and the assessment tasks should reflect the objectives. This may appear to be a statement of the obvious, but few subjects satisfy these criteria. The traditional CS1 approach is to set students the task of writing extensive code, as early as possible. On closer inspection of such subjects, one finds marking schemes for exams and assignments that are generous to the point of being inconsistent with the subject objectives. Instead, students should not write any original code in CS1, and should be examined by multiple choice question.
In support of student pair-programming
Authors: Williams Laurie , Upchurch Richard L.
Published: July 2004

Industry, particularly those following the eXtreme Programming (XP) methodology [2], has popularized the use of pair-programming. The pair-programming model has also been found to be beneficial for student programmers. Initial quantitative and qualitative results, which will be discussed in this paper, demonstrate that the use of pair-programming in the computer science classroom enhances student learning and satisfaction and reduces the frustration common among students. Additionally, the use of pair-programming relieves the burden on the educators because students no longer view the teaching staff as their sole form of technical information. We explore the nature of pair-programming, then examine the ways such a practice may enhance teaching and learning in computer science education.
Binary software components in the undergraduate computer science curriculum
Authors: Parrish Allen , Dixon Brandon , Cordes David
Published: July 2004

At one time, commercial software applications were released as single binary executable files. Discussions of the notion of a "software component" were almost always limited to the context of source code. However, with the proliferation of numerous new technologies, applications are now more typically released as collections of cooperating binary components. While there is significant industrial emphasis on binary component technologies, computer science curricula have not yet standardized upon a corpus of fundamentally sound concepts to support education within this paradigm. In this paper, we describe our efforts to define a fundamental core set of concepts to support this important programming paradigm, as well as our efforts to integrate these concepts into a typical undergraduate computer science curriculum.
A reusable graphical user interface for manipulating object-oriented databases using Java and XML
Authors: Dietrich Suzanne W. , Suceava Dan , Cherukuri Chakrapani , Urban Susan D.
Published: July 2004

This paper describes the design and functionality of a graphical user interface (GUI) written in Java Swing that is used to support instructional activities associated with teaching object-oriented database (OODB) concepts. The GUI supports the manipulation of objects in an OODB, assuming the implementation of a specified interface for interacting with an OODB. By using the interface, students can focus on object-oriented design and programming concepts associated with OODB concepts rather than the development of a user interface. Since the GUI uses the Extensible Markup Language (XML) for defining the database schema and data import/export, the use of the GUI provides the added benefit of demonstrating the manner in which XML interacts with database technology.
Preparing students for internet and multimedia technology careers
Authors: Harmeyer Kathleen , Tupper Donna , Beck William , Sorkin Sylvia
Published: July 2004

This paper provides descriptions of three courses in a thirty-credit Internet and Multimedia Technology (I/MMT) certificate program. They are: Multimedia Authoring II, Project Development, and Internet Programming. The latter has been offered in both traditional and online versions at the Essex Campus of the Community College of Baltimore County (CCBC-Essex).
Why I do declare!
Authors: Rebelsky Samuel A. , Henderson Peter B. , Kumar Amruth N. , Springsteel F. N. (Fred)
Published: July 2004

Many curricular guidelines, such as the Recommended Curriculum for Computer Science at Liberal Arts Colleges [4], suggest that students be exposed to many different programming paradigms (e.g., imperative, functional, object-oriented, declarative) in the undergraduate curriculum. Some institutions believe that students should have early exposure to many paradigms, often as early as the first two courses.Many institutions emphasize object-oriented programming early in the curriculum. Some also include functional programming. Imperative topics are often covered in courses that emphasize object-oriented or functional issues. Where does declarative programming fit? Sometimes not until an upper-level language paradigms course or artificial intelligence course. Sometimes it never fits, at least not explicitly.
Teaching using off-the shelf on-line materials
Authors: Alphonce Carl , Burhans Debra , Kershner Helene , Sherman Barbara , Walters Deborah , Eddy Erica , Melara Gloria , DePasquale Pete , East J. Philip , Springsteel Fred , Lauckner Kurt F.
Published: July 2004

The use of off-the-shelf on-line materials presents several challenges. In this session panelists report on their experiences in evaluating, installing and using such materials. Both positive and negative aspects of such use are discussed. The aim of the session is to provide useful information to those considering using (and those already using) on-line materials in their teaching. The session presents information in three mini-presentations, followed by a general discussion session.
A note on the expected distribution of degrees in random binary trees
Authors: Siltaneva Jarmo , Mäkinen Erkki
Published: July 2004

We derive the expected numbers of nodes with 0, 1, and 2 children in random binary trees by using only elementary methods and concepts.
Using multiplayer games to teach interprocess communication mechanisms
Authors: Reese Donna S.
Published: July 2004

An advanced operating system (OS) course teaches students how the OS mechanisms that they have learned in OS I are implemented. Solaris and Windows NT are used to illustrate these implementations. This course covers the major aspects of OS functionality and addresses both OS design issues and user level programming issues. The area of inter-process communication is not conceptually difficult for students to grasp, but the actual implementation and use of these concepts requires some practice. For the past three years, the author has experimented with the use of multi-player games as a mechanism for teaching students these programming constructs. This paper reports on these experiences.
Real-world problem-solving, pedagogy, and efficient programming algorithms in computer education
Authors: Bossé Michael J. , Nandakumar N. R.
Published: July 2004

Modern research and curricular reforms equate pedagogical soundness with the connection of instructional content with real-world problems. Software engineers facing real-world computer problems are continually concerned with the efficiency of the program that they write. Divorcing programming concerns from efficiency unsatisfactorily presents the responsibilities and full concerns of computer programmers. Therefore, when programming tasks are simplified to avoid concerns for efficiency, the assignments become antiseptic, lose the nature of real-world problems, and become inconsistent with the true nature of computer programming concerns. This brief investigation considers real-world problems, pedagogy within computer programming education, and the often-missed consideration of efficiency within instructional computer programming assignments.
If-then-else
algorithms are compared with algorithms using arrays in light of programming efficiency and pedagogy in computer education.
Dining philosophers in JSD
Authors: Kokol P.
Published: July 2004

In this article we use the JSD methodology in solving a classical problem: the problem of "Dining philosophers".
Formal requirements specification of process control systems
Authors: Hagemann M.
Published: July 2004

The increasing size of software systems
requires methods and tools for their development
. Currently only a few tools are practically used. This paper presents a system which was developed in order to support requirements specification of process control systems. The paper introduces a formal language and describes, how the system supports the steps from ideas to a formal requirements specification.
A prototyping tool for graphical software engineering tools
Authors: Miyamoto I.
Published: July 2004

The paper introduces (1) a meta system, ERA Meta-Graph System, to define graphical modeling formalisms and to prototype their rule-based graphical editors, and (2) an example usage of the system to prototype some rule-based diagram editors for software designing process.
Screening freshmen computer science majors
Authors: Gathers Emery
Published: July 2004

Ten factors were studied to determine their relationship to success in the first computer science course (Programming Concepts and Problem Solving) for majors. The ten factors studied were the following: high school grade point average, ACT scores (English, math, social science, natural science, and composite), Nelson Denny Reading scores (vocabulary, comprehension, and total grade equivalent), and the UTM Math Placement Test score. Of these placement factors, only the ACT English score and the UTM math placement test were significant in reducing the failure rate in the first course in computer science for majors. The ACT English score was the single best predictor of success.
The use of mediation and ontology technologies for software component information retrieval
Authors: Braga Regina M. M. , Mattoso Marta , Werner Cláudia M. L.
Published: July 2004

Component Based Developed aims at constructing software through the inter-relationship between pre-existing components. However, these components should be bound to a specific application domain in order to be effectively reused. Reusable domain components and Their related documentation are usually stored in a great variety of data sources. Thus, a possible solution for accessing this information is to use a software layer that integrates different component information sources. We present a component information integration data layer, based on mediators. Through mediators, domain ontology acts as a technique/formalism for specifying ontological commitments or agreements between component users and providers, enabling more accurate software component information search.
An approach to designing reusable service frameworks via virtual service machine
Authors: Jang Jun-Jang
Published: July 2004

This paper proposes a new service-computing platform named Virtual Service Machine (VSM). Service computing is a new paradigm for manufacturing IT artifacts, lifting up traditional focus of software development from the level of applications to that of services. Applications are constructed for machines; services are built for people. Applications are targeted to run on a particular platform; services are aimed for serving user's needs. While service computing is getting much more attention than before, its progress is slow and outcomes are not so gratifying. Many service-computing developers are striving to solve the same problems encountered in their counterparts on application development. Middleware is one of many means to address the issue of development barriers for services. However, current forms and functions of middleware software are still impeded by customary mindsets that have been exercised for last couple of decades. We need a new breed of platforms that can further relieve the developers from low-level platform concerns, e.g. hardware, OS, or even middleware itself. VSM is a way towards more effective service- computing development. It provides developers with a reusable service- computing platform to develop their service- based frameworks and applications. This paper proposes an approach of designing reusable service- computing platform via VSM. VSM works by taking incoming service requests and converting them to the executable tasks of the underlying middleware or machine that it is running on. This paper emphasizes on presenting the functionality and major components inside VSM. The comparative study with other service- computing platforms with not be the focus of this paper.
Product line software engineering of embedded systems
Authors: Niemelä Eila , Ihme Tuomas
Published: July 2004

In order to be able to determine whether the product line approach is suitable, a company needs to analyse its business drivers, commonality of existing products, domain knowledge owned by the engineering staff, and quality of the representations of existing software artefacts. In this paper we present evaluation criteria for the development of a product line and give an overview of the current state of practices in the embedded software area. Evaluation criteria are divided into three classes. Business drivers of a product line are defined by analysing product assortment and business manners. Domains and personnel are considered in the analysis of the preconditions and targets of a product line. In the development of core assets, elements that affect assets engineering are considered as well as the mechanisms needed in their maintenance. A product line architecture that brings about a balance between sub- domains and their most important properties is an investment that must be looked after. However, the subdomains need flexibility to use, change and manage their own technologies, and evolve separately, but in a controlled way.
Violatility analysis framework for product lines
Authors: Savolainen Juha , Kuusela Juha
Published: July 2004

Evolution of a software intensive system is unavoidable. In fact, evolution can be seen as a part of reuse process. During the evolution of the software asset, the major part of the system functionality is normally reused. So the key issue is to identify the volatile parts of the domain requirements. Additionally, there is promise that tailored tool support may help supporting evolution in software intensive systems. In this paper, we describe the volatility analysis method for product lines. This highly practical method has been used in multiple domains and is able to express and estimate common types of evolutional characteristics. The method is able to represent volatility in multiple levels and has capacity to tie the volatility estimation to one product line member specification. We also briefly describe current tool support for the method. The main contribution of this paper is a volatility analysis framework that can be used to describe how requirements are estimated to evolve in the future. The method is based on the definition hierarchy framework.
Efficient coverage testing using global dominator graphs
Authors: Agrawal Hira
Published: July 2004

Coverage testing techniques, such as statement and decision coverage, play a significant role in improving the quality of software systems. Constructing a thorough set of tests that yield high coverage, however, is often a very tedious, time consuming task. In this paper we present a technique to find a small subset of a program's statements and decisions with the property that covering the subset implies covering the rest. We introduce the notion of a mega block which is a set of basic blocks spanning multiple procedures with the property that one basic block in it is executed iff every basic block in it is executed. We also present an algorithm to construct a data structure called the global dominator graph showing dominator relationships among mega blocks. A tester only needs to create test cases that are aimed at executing one basic block from each of the leaf nodes in this directed acyclic graph. Every other basic block in the program will automatically be covered by the same test set.
Efficient and precise modeling of exceptions for the analysis of Java programs
Authors: Choi Jong-Deok , Grove David , Hind Michael , Sarkar Vivek
Published: July 2004

The Factored Control Flow Graph,
FCFG,
is a novel representation of a program's intraprocedural control flow, which is designed to efficiently support the analysis of programs written in languages, such as Java, that have frequently occurring operations whose execution may result in exceptional control flow. The FCFG is more compact than traditional CFG representations for exceptional control flow, yet there is no loss of precision in using the FCFG. In this paper, we introduce the FCFG representation and outline how standard forward and backward data flow analysis algorithms can be adapted to work on this representation. We also present empirical measurements of FCFG sizes for a large number of methods obtained from a variety of Java programs, and compare these sizes with those of a traditional CFG representation.
Micro-Architecture of Software Components and The Need For Good Mental Models of Software Subsystems
Authors: Edwards Steve
Published: July 2004

Because of similar interests, these two groups initially met together, and then decided to jointly pursue both topics. ¿From the micro-architecture perspective, the group was interested in the details of both the structure and the behavior of software component interfaces and on the implementations of individual components, sets of components, and how they compose and "interoperate" with each other. From the mental models perspective the group was interested in exploring the methods by which humans develop good mental models of generic software subsystems, the methods by which one can design software interfaces that "project" easy-to-assimilate mental models, and how existing programming languages support/hinder these efforts.
A software engineering approach to introductory programming courses
Authors: Alford M. , Hsia P. , Petry F.
Published: July 2004

This paper describes an approach that can introduce some of the concepts of software engineering to general business, engineering, and science students in an introductory FORTRAN programming course. The approach integrates the notions of top-down design, stepwise refinement, structured flowcharting, test case description, and analysis in the context of a methodology for systematically developing and documenting programs. Qualitative results from teaching these concepts are presented.
A structured approach to problem solving at the introduction level in computer science
Authors: Pitts Gerald N. , Bateman Barry L.
Published: July 2004

Problem solving is a task which is basic to many every day situations. Generally, people are not fully aware of the thought processes which enter into the solution of their particular situation. A problem presents itself and the solution, if determined, is implemented. Humans are able to solve problems in a relatively informal manner. Computers, due to their limited abilities, usually cannot be used to solve problems in this fashion. Greater success in computerized problem solution is often attained through strict, rigid expression of the problem and of its solution (i.e. a structured approach).

There are a variety of techniques which one can use in formally defining a problem situation. One that has found some favor is to precisely define the problem by subdividing it into lesser problems and then to define the subproblems into lesser problems until the entire problem has been broken into relatively elementary operations. The problem and all of its subdivisions are then analyzed in order to determine the required input values (i.e. what information or action does each segment need in order to perform its function properly?), and the required output values (i.e. what information or action does the step produce in order for succeeding steps to perform their function properly or for the solution to the problem to be furthered?). Completion of the subdivision and analysis steps is followed by translation of the problem into a computer language and by the subsequent testing of the solution to insure that it is truly correct.

Four commonly used methods for expression of the analyses of the problem are a word description of the problem, a list of the major points of the problem, a “flowchart” of the problem, or an artificial language (commonly a computer language) description of the problem solution. Quite often a combination of the four basic methods is employed. The main purpose of the methods is to completely define the problem and its solution so that every facet of these two items is completely understood. Consequently, it is best to employ whatever method or combination of methods one finds easiest to use in order to further his comprehension of the problem.
The university - a systems development center for state government or How to solve the education vs. training problem
Authors: Peck John C.
Published: July 2004

During the past few years, I have attended several professional meetings which have included panel discussions between representatives from industry and academia concerning computer science education. Industry usually claims that students graduate with few practical skills - many can't even write a program as simple as a master file update. They further complain that such major issues as documentation, programming style, and team programming are neglected, while the abilities for written expression and oral presentation are often totally lacking. The programming languages which are common in industry (COBOL, FORTRAN) are often not introduced, and actual experience in the use of data base and data communications software just doesn't exist. In summary, universities are not interested in preparing a student for an industrial career.

Universities usually respond by stating that their mission is education and not training. They are not attempting to produce a technician who will be obsolete in two years, but rather are attempting to build a base of knowledge which will allow the professional to change with the times. Many claim that they are describing topics on the frontiers of the field which will be used ten years from now. Since universities are expected to be “pioneers”, they are required to lead in the development and research of new technology.
Women in science
Authors: Dale N.
Published: July 2004

Women make up 51% of our population, yet they represent only 10% of those currently employed as scientists. Recognizing the underutilized scientific resource that women represent the congress of the United States directed the National Science Foundation to make available not less than $1,500,000 to develop and test methods of increasing the flow of women into scientific careers. (Public Law 94-80, 1976)

To carry out this mandate, NSF sent out a call for proposals in early 1976. The proposals were to be of two kinds: (1) Science Career Workshops where women students would be introduced to and hopefully motivated into choosing careers in the sciences and (2) Career Facilitation Projects where women who have scientific training but are not using it could be brought up to date and made ready to enter the job market or enter graduate school.

This paper describes the Career Facilitation Project being undertaken by the Computer Sciences Department of the University of Texas at Austin, supported by the National Science Foundation under Grant #SMI6-20420.
An experiment with an introductory course in computer science
Authors: Chanon R. N.
Published: July 2004

During the spring semester of 1977 an experiment was undertaken to determine whether the introductory course in computer science could teach more that it has in the past. The experiment, as a whole, indicated that it is indeed possible to provide more content. Students responded well and learned more. This paper discusses an informal experiment; what motivated it; our methods; and finally its results.
Computer manpower in the United States-supply and demand
Authors: Hamblen John W.
Published: July 2004

Results of a survey conducted by the author in late 1974 are presented and used to give estimates of Computer Manpower production for 1974-75. These production estimates are compared with needs estimates presented in an earlier paper (SIGCSE Bulletin December, 1975). All postsecondary institutions were surveyed and a 61% response was obtained. Lists of degree programs reported in the Computer Sciences are also presented.
A search for interactive computer graphics lessons in numerical analysis
Authors: Corliss George
Published: July 2004

A search for interactive computer graphics lessons which could be used in numerical analysis courses at the University of Nebraska - Lincoln confirmed that few such Lessons exist and that even fewer can be transported from one site to another. Some Lessons were written on the three different host systems available locally. A list of suitable Lessons known to exist is included.
An introductory computing science course for liberal arts students
Authors: Smillie K. W.
Published: July 2004

This paper discusses an introductory course in computing science in
which the subject is developed in an historical setting beginning with ancient Egypt and Babylon and continuing until the present time.
Predicting student success in an introductory programming course
Authors: Hostetler Terry R.
Published: July 2004

This paper examines to what extent a student's aptitude in computer programming may be predicted through measuring certain cognitive skills, personality traits and past academic achievement. The primary purpose of this study was to build a practical and reliable model for predicting success in programming, with hopes of better counseling students. Results from correlating predictor variables with a student's final numerical score confirmed past studies which showed the diagramming and reasoning tests of the Computer Programmer Aptitude Battery and a student's GPA to be the predictors most closely associated with success. A multiple regression equation developed from 5 predictors correctly classified 61 of 79 students (77.2%) into low and high aptitude groups.
A pictorial demonstration of concurrent processes
Authors: Colville John
Published: July 2004

A set of programs is described, which demonstrates a number of the concepts associated with the operation of concurrent processes. Concepts which are demonstrated include interrupts, concurrent execution, synchronization and deadlock. The programs interpret a simple language which includes semaphores and so is able to show producer/consumer systems. The programs are run on a variety of terminals including a colour graphics terminal which enables a vivid presentation.
The role of discrete structures & operations research in a computer science curriculum
Authors: Martin Kenneth E.
Published: July 2004

The purpose of this paper is to present a description and rationale for the latter two courses, as well as a recommendation for their placement within the curriculum. It is the author's belief that both courses should be seriously considered as required courses in an ACM type recommendation for the reasons which will be outlined.
Using microcomputers in computer education
Authors: Chua T. S. , McCallum J. C.
Published: July 2004

This paper discusses the background and difficulties of using microcomputers in computer education. It considers the ways in which microcomputers can be introduced onto the educational institutions. The advantages and disadvantages of the various options are discussed. The paper also discusses the problems faced by the educators in the use of microcomputers in computer education.
A problem oriented pedagogy for computer language instruction
Authors: Senn James A.
Published: July 2004

Training in computer languages has become an integral part of most programs in the Decision Sciences. However, in many instances, the educational efforts have focuses primarily on language syntax and structure, where short programming problems are assigned to students in order to emphasize a particular technique or subset of of instructions in the language. Such an approach implicitly avoids the overall purpose of computer language instruction: providing the student with a means of integrating the computer into problem solving activities.The purpose of this discussion is to introduce several techniques which have proven effective in teaching not just language syntax and structure, but also modular programming and documentation for business oriented problems. Each of these topical areas needs to be addressed in programming language courses in such a way that the student not only gains a meaningful understanding of the concepts, but also grasps an awareness of the particular value of the concept in business applications. A methodology is presented which has successfully been adopted in computer programming courses at both the graduate and undergraduate levels.
Grade and ability predictions in an introductory programming course
Authors: Newsted Peter R.
Published: July 2004

Two regression equations are derived to predict grade and ability in an introductory FORTRAN course. College GPA, programming experience, and career orientation are shown to be significant positive predictors; working in groups and time spent on the course are unexpectedly shown to be negative correlates. The implications of these findings for methods of teaching programming are discussed.
Problem of computer science education in small colleges
Authors: Wegner Peter
Published: July 2004

These notes are a summary of views developed by the author during a visit to three small colleges under the auspices of the ACM College Consulting Service. The technological, financial and sociological problems at each of the colleges were remarkably similar, and it is hoped that this report may serve a purpose both in acquainting the computer science profession with the problems of small colleges and in helping small colleges to gain some perspective with regard to the purposes and problems of computer science education.
The pyramid teaching computer structures by computer structures
Authors: Epstein G.
Published: July 2004

The content of the laboratory portion of a course on computer structures is given in syllabus form. Each succeeding level of the syllabus builds upon the preceding level to achieve increased understanding and depth of thought. The syllabus provides annotated examples of structures and projects for each level.
Programming for terminal applications
Authors: Porter Charles H. , Wu Nesa Labbe
Published: July 2004

When a computer language is taught in the classroom, the focus is usually on the language itself and its application to the students' fields of interest. Syntax and logic are the chief barriers to be overcome, and, as a result, an important topic is not covered. This area is becoming more a problem with the trend toward writing computer programs to be run from a terminal. Students are not being taught how to write a program to be run by someone else.This article develops a set of rules to improve programs for terminal applications. These rules center around:1. Data Validation: The Programmer must explicitly test the data entered to be sure it is of a valid type and within valid range;2. Input and Output Validation: It is important to identify the problem being solved, the input to the program and the results of the program; and3. Data Flow: The flow of data into the computer should be ordered in the same way as it would be if a person were solving a problem in his head.If these rules are followed, programs will perform better, the user will be happier, and the data processing will be more accurate.
A computer science minor for engineering and science students
Authors: Sondak Norman E.
Published: July 2004

There has been a great demand for scientists and engineers to become thoroughly acquainted with the application of digital computers to their discipline areas. As a result, engineering and science majors have been interested in complimenting their programs with a minor in Computer Science. Traditionally, minor programs required a specific number of thematically related courses in the minor discipline. However, this traditional approach does not necessarily fulfill the real demands of the students involved in Computer Science. A suggested minor program is presented with a review of experiences.
Video augmented computer science (VACS)
Authors: Gross James F.
Published: July 2004

The design and production of videotapes showing simple algorithms in action is described. Fortran programs and a CRT timesharing terminal allow the computer to generate animated representations of arrays as they are searched or sorted. Problems encountered during the project are outlined, along with the solutions.
Structured programming in assembly language
Authors: van Dam Andries , Dill Jens M. , Dixon Douglas F. , Notkin David S.
Published: July 2004

Structured design and programming techniques can be extended from high-level languages to assembly language. Over the past three years at Brown University, beginning assembly language programmers have been successfully taught these techniques using clearly defined standards. These standards and the solutions to several of the typical problems that arise in structured assembly language programming are discussed in this paper.