bluuebunny/crossref_metadata_2025 huggingface dataset:
4th ICSE workshop on component-based software engineering
Authors: Crnkovic Ivica , Schmidt Heinz , Stafford Judith , Wallnau Kurt
Published: July 2004

This paper gives a short overview of the 4th ICSE Workshop on Component-based Software Engineering. The workshop brought together researchers and practitioners from three communities: component technology, software architecture, and software certification. The goal of the workshop was to find a common understanding and to discuss the topics related to the component composition. The workshop was divided in eight sessions held in sequence, starting with invited talks and ended with a final discussion. A model problem, to be used for further research and work in future workshops, was discussed and later selected. The paper gives a comprehensive summary of the sessions and plans for future work.
ICSE2001 workshop to consider global aspects of software engineering professionalism
Authors: Thompson J. Barrie
Published: July 2004

The prime aim of the workshop was to provide a forum to consider global aspects of a Software Engineering profession and determine the relevance and usefulness of an initiative concerning the harmonization of professional standards which had been produced under the auspices of the International Federation of Information Processing. In particular the workshop addressed: the current situation with regard to models of certification and/or licensing in different countries, the drivers and constraints regarding Software Engineering professionalism, the roles of: international bodies and organisations, professional bodies, and learned societies. Also open questions and actions for the future were identified. The planned and the actual operation of the workshop are described. The discussion sessions are outlined and the major issues resulting from these discussions are presented. Post workshop conclusions are reported, as are relevant international developments that have occurred in the three months following the workshop. Also included are two appendices: one providing background information to the workshop the other providing a copy of the IFIP harmonization document,
A user requirements elicitation tool
Authors: Laguna Miguel Angel , Marqués José Manuel , García Francisco José
Published: July 2004

Use cases are nowadays the favoured technique for defining the functional requirements of a software system. Their use implies that most of the desired functionality of the new system is well known. The aim of this work is a methodological proposal (and a tool to support it) to accurately define this functionality, starting from the way the end users currently do their work. This method and tool are independent of the development paradigm and could generate useful results for the most frequently used CASE tools with the addition of the appropriate translators.
The role of Java RMI in designing workflow management system
Authors: Shaofeng Wang
Published: July 2004

The development of the workflow management system(WfMS) has become one of the most important research areas in information system. The design of the WfMS is a very complicated process, involving many difficult tasks. In this paper, We discuss the design of Java RMI-based workflow management system JWfMS, mainly on the designing framework of the JWfMS. According to our experience, we found that Java RMI is suitable and practical for the design of heterogeneous, distributed system such as WfMS because Java RMI makes the design and maintenance work much simpler.
Optimizing software process control
Authors: Sukhodolsky Jacob
Published: July 2004

An important problem in software project management is taking control decisions when a schedule slip occurs. Usually such decisions are based only on the manager's experience and intuition. They are often prohibitively costly and still do not guarantee the project's success. This article presents a method for finding the optimal control actions the manager should take to meet a project's deadline in a situation when a schedule slip occurs. The method is based on using a discrete optimization technique, such as dynamic programming. Validation of the method's effectiveness is also included.
An XML-based approach to automated software testing
Authors: Bird Colin , Sermon Andrew
Published: July 2004

The advantages of automating the functional testing of application software are well-known, but the manner of automation can lead to difficulties in authenticating the test coverage. In this paper we consider the class of automated tests in which a driver tool simulates the input and responses of a human operator and sequentially checks the output generated by the application software. The driver tool commonly employs its own language to describe the tasks it can be required to perform, for example:• Issue a sequence of characters that simulate input from the keyboard.• Verify that a segment of the display buffer contains the expected bit pattern.Although these tasks are simply stated, the language to effect them in a test script can become complex and hard to maintain. Furthermore, reading the driver tool program is not an effective way to confirm that the test script performs its tasks to the test specification.XML (eXtensible Markup Language)[1)] scripts offer a rigorous intermediate description that can be readily translated into both the driver tool test script and a readable statement of the task the test performs. The advantages accruing from the use of XML are:• The XML scripts are easy to edit, simplifying basic script maintenance. New steps can be included for testing bug fixes.• Content review becomes much easier, as the relevant aspects of the script can be rendered in a readily readable form, such as HTML;• Global changes become feasible, as the structured nature of XML documents makes it possible to search for specific element content;• The structure of the XML document can itself be checked, for example using a validating editor such as Xeena [2)].In the next section we describe an example of automated testing using a driver tool, based on XML scripts. The application being tested is called Wired for Learning [3)] and provides the IT infrastructure for schools to:• Enhance communication between teachers, students and parents.• Enable teachers to plan and share ideas for lessons and activities, linking in with national standards.• Organize team projects involving teachers and students across classes and schools, with the option of inviting members of the community to provide additional information.• Provide an events calendar to keep everyone up to date with what is happening in the school.• Allow teachers easily to create their own home pages for information dissemination.
Suitability assessment of software developers
Authors: Lather Anu Singh , Kumar Shakti , Singh Yogesh
Published: July 2004

The right selection of software personnels helps keep project cost low, deliver better quality software and avoids the schedule slippage of a software project. We have identified the 3 most essential abilities/aptitudes which can decide comparative merit of the software developers. These are Verbal Reasoning (VR), Numerical Ability (NA) and Abstract Reasoning (AR). As a fuzzy model is a best choice for managing ambiguous, doubtful, contradicting and diverging opinions we propose a three input and single output fuzzy model to unify the crisp output of the 3 tests (i.e., VR, NA, AR). The output of the proposed fuzzy model a single numerical value that decides the merit of a developer based on the scores he obtains in VR, NA and AR.
An efficient method for expressing active object in C++
Authors: Chen Wang , Ying Zhou , Defu Zhang
Published: July 2004

Object-Oriented technology is fit for the construction of open systems. However, how to express distributed or concurrent objects has not been resolved in nowadays OO language. The active object concept is one kind of generalization of concurrent or distributed objects. We analyzed the characters of active objects in detail and propose an efficient method to express active behaviors in Object-Oriented language such as C++. What we lay stress on is to express active objects' two major features: concurrency and cooperative, especially the latter. The reusability of active objects is emphasized as well.
The first international workshop on automated program analysis, testing and verification
Authors: Penix John , Tracey Nigel , Visser Willem
Published: July 2004

This paper reports on the First International Workshop on Automated Program Analysis, Testing and Verification (WAPATV) held in Limerick on the 4th-5th June 2000, as part of the International Conference on Software Engineering 2000. We begin by presenting an overview of the workshop aims and then focus on the workshop's technical program.
Practical data exchange for reverse engineering frameworks
Authors: Godfrey Michael W.
Published: July 2004

Reverse engineering systems hold great promise in aiding developers regain control over long-lived software projects whose architecture has been allowed to "drift". However, it is well known that these systems have relative strengths and weaknesses, and to date relatively little work has been done on integrating various subtools within other reverse engineering systems. The design of a common interchange format for data used by reverse engineering tools is therefore of critical importance.In this position paper, we describe some of our previous work with TAXFORM (Tuple Attribute eXchange FORMat) [2,6], and in integrating various "fact extractors" into the PBS reverse engineering system. For example, we have recently created translation mechanisms that enable the Acacia system's C and C++ extractors to be used within PBS, and we have used these mechanisms to create software architecture models of two large software systems: the Mozilla web browser (2.2 MLOC of C++ and C) and the VIM text editor (150 KLOC of C) [6]. We also describe our requirements for an exchange format for reverse engineering tools and some problems that must be resolved.
Learning the interaction between pointers and scope in C++
Authors: Kumar Amruth N.
Published: July 2004

Traditionally, pointers, and their interaction with scope in C++ have been a source of frustration and confusion for students in our Computer Science II course. Since problem-solving is known to improve learning [6], we set out to develop software that would help our students better understand these concepts by repeatedly solving problems based on them.In this paper, we will first describe the design and features of this software. We conducted tests in two sections of our Computer Science II course this fall to evaluate the effectiveness of using this software. The results have been very encouraging: the class average in both the sections increased by 100% from the pretest to the post-test. We will also present the design and results of these tests.
Requirements for an educational software development process
Authors: Filho Wilson P. Paula
Published: July 2004

Software engineering education must provide the students with knowledge and practice of software development processes. These must be used in course projects, to confront the students with realistic software engineering issues. A requirements set for educational software development processes is proposed here. It includes requirements about process architecture, team orientation, project life cycle, standards and practices, student support and instructor support. Some published real-life processes were evaluated against these requirements, and a new process was designed to meet them.
Metacognitive awareness utilized for learning control elements in algorithmic problem solving
Authors: Ginat David
Published: July 2004

Students who demonstrate high self-explanation ability show advanced metacognitive awareness of their own problem solving process. This awareness can be utilized to reveal and apply control elements they experience during problem solving. In this paper we present a study of capitalizing on student awareness for developing their control competence during algorithmic problem solving. We describe the rational for our study, illustrate the learning process through an initial problem solving activity, and show the outcome of this learning.
Scaffolding learning in virtual environments
Authors: Chalk Peter
Published: July 2004

As the use of on-line teaching environments increases, tutors need to identify the tasks, procedures and interventions that enhance the quality of student learning. One theory of instruction in problem solving is scaffolding and this is used as a guide to analysis of actual interventions by the author in a software engineering assignment. Stored models of the students' solutions show various misconceptions and the tutor's comments in each case are shown to belong to one of the six categories listed in the original definition of scaffolding. One possible outcome could be the outline of a possible new instructional design pattern for this method of tutoring.
Versatile concept map viewing on the Web
Authors: Karvonen Antti , Rautama Erkki , Tarhio Jorma , Turkia Jari
Published: July 2004

We present an applet-based system viewing concept maps on the Web. The input consists of a concept map written in a description language with optional style and layout definitions. The system has numerous applications, because many kinds of graphs, trees, and flowcharts written by humans or generated by other software can be shown in addition to traditional concept maps.
Accreditation and student assessment in distance education
Authors: Kaczmarczyk Lisa C.
Published: July 2004

Distance Education (D.E.) is changing fundamental debates about academic integrity and rigor. The role of teaching and learning is being discussed with respect to both accreditation and student assessment. Evidence suggests that popular methods of student assessment in D.E. differ little from traditional methods. Studies of cheating in D.E. show that perceptions do not match reality. Accrediting agencies are grappling with an inherent educational paradigm shift. Beliefs about professional autonomy and academic freedom may be affected. Computer Scientists are in a unique position to understand the implications of this technology-driven debate. We need to educate ourselves about these issues and make our voices heard.
A system for program visualization and problem-solving path assessment of novice programmers
Authors: Satratzemi Maria , Dagdilelis Vassilios , Evagelidis Georgios
Published: July 2004

This paper describes an educational programming environment, called AnimPascal. AnimPascal is a program animator that incorporates the ability to record problem-solving paths followed by students. The aim of AnimPascal is to help students understand the phases of developing, verifying, debugging, and executing a program. Also, by recording the different versions of student programs, it can help teachers discover student conceptions about programming. In this paper we describe how our system works and present some empirical results concerning student conceptions when trying to solve a problem of algorithmic or programming nature. Finally, we present our plans for further extensions to our software.
The NetWire emulator
Authors: Carniani Enrico , Davoli Renzo
Published: July 2004

The evolution of the parallel computing theory has shown over years the need for complex and reliable emulation tools for teaching, learning and developing new distributed algorithms in a realistic network environment.
NetWire[emu]
is a distributed architecture designed for educational and research purposes which provides a synthetic and realistic network environment that may be used to teach and learn parallel algorithms (or parallel operating systems) as well as to research and develop new distributed algorithms.NetWire is an architecture based on a client/server derivation scheme: each client can interact with one or more servers emulating one or more networks by the NOEL protocol (Network Oriented Emulation Language), which is an extension of TCL over TCP/IP specifically designed for NetWire. The user can thus control all the physical parameters of each network or part of it (communication channels, hubs, network adapters and so on).Furthermore, the NetWire API library interfaces the synthetic network environment to real software applications with ease, hiding the whole architecture behind the appearance of a network device driver, fully compatible with the operating system the applications run on.Moreover, NetWire already provides a featured Xwindows interface, and because of the integrated TCL language and the interactions between NOEL and TK, it is possible to fastly build up new and powerful GUI based programs.Thus, the field of application of NetWire is twofold: on a side, it may be used as a tool for teaching distributed algorithms on parallel and distributed operating systems, and on the other one it is a tool for the research and development of new distributed algorithms.
Enhancing the computer networking curriculum
Authors: Rickman Jon , McDonald Merry , McDonald Gary , Heeler Phillip
Published: July 2004

An increasing number of students in computer science are requesting advanced study and active learning experiences in computer networking. Employers need graduates who not only understand the fundamentals of networking but those who can quickly be involved in network administration. Meeting these demands in the curriculum suggests that new and well-planned laboratory and internship experiences should be incorporated into the computer science curriculum. However, there are some major challenges in providing these experiences; it is much more complex than just adding another compiler or server to a laboratory. This paper describes several efforts the authors are making to meet these challenges.The environment in which these efforts have been studied is a small state-supported university, Northwest Missouri State University, in rural Missouri. Northwest has over 6,200 students pursuing baccalaureate, masters and specialist degrees. The networking environment at Northwest is more robust than one might expect. In 1987, the University became the first public institution in the United States to develop an "Electronic Campus" featuring University-provided, networked computing stations located in every residence hall room and faculty office. Then in 1999, each faculty member was issued a personal notebook computer and the residence halls were upgraded to Windows-based, networked desktop computers. [9]
Teaching abstraction explicitly (poster session)
Authors: Koppelman Herman
Published: July 2004

When one has to learn programming one has to learn a programming language, but also the concept of abstraction. Learning abstraction is not a logical consequence of learning a programming language. Moreover, it can be doubted whether novice programmers naturally tend to use abstraction. So, our approach is to teach abstraction explicitly to novices. We show that even for simple problems it makes sense to look for levels of abstraction in the problem definition and subsequently to design programs that reflect explicitly those levels of abstraction.We will discuss the way it works on the basis of a simple example.
Use petri nets to improve your concurrent programming course (poster session)
Authors: Barros João Paulo
Published: July 2004

Petri nets are recommended as a learning aid in a concurrent programming course covering modelling and verification techniques, based on state space analysis, and translation of formal models to Java programs.
Accreditation and student assessment in distance education (poster session)
Authors: Kaczmarczyk Lisa C.
Published: July 2004

Distance Education (D.E.) is changing fundamental debates about academic integrity and rigor. The role of teaching and learning is being discussed with respect to both accreditation and student assessment. Evidence suggests that popular methods of student assessment in D.E. differ little from traditional methods. Studies of cheating in D.E. show that perceptions do not match reality. Accrediting agencies are grappling with an inherent educational paradigm shift. Beliefs about professional autonomy and academic freedom may be affected. Computer Scientists are in a unique position to understand the implications of this technology-driven debate. We need to educate ourselves about these issues and make our voices heard.
Using Prolog to present abstract machines
Authors: Crookes D.
Published: July 2004

Introductory courses in Theory of Computation usually include a study of abstract machines such as finite state machines and Turing machines. This paper demonstrates that a neat and useful way of presenting these automata is to use a logic programming language such as Prolog, making the approach useful from a teaching point of view. Not only does a Prolog specification provide a precise definition of an automoton's behaviour, but it also gives an immediately-executable simulator. The reversible execution property of Prolog programs can make these simulators inherently more powerful than traditional simulators. The paper includes Prolog specifications for finite state machines, Turing machines, linear bounded automata, and pushdown automata.
The trouble with for-loop invariants
Authors: Collins William J.
Published: July 2004

In this paper we discuss some of the problems in constructing and utilizing loop invariants for For-loops. Another kind of assertion, the loop post-invariant, is offered as an alternative to the loop invariant in designing, documenting and proving the correctness of For-loops.
File processing—a correctness approach
Authors: Plishka Richard M.
Published: July 2004

This paper describes an upper-division course in file processing which is intended to satisfy the requirements of both theoretical and applications-oriented curricula. It emphasizes file processing concepts from a software engineering perspective. Attention is paid to the system life cycle and a correctness approach to design and coding.
Requiring CS1 students to write requirements specifications: a rationale, implementation suggestions, and a case study
Authors: Brown Dale A.
Published: July 2004

This paper offers arguments supporting the concept of requiring written requirements specifications for all programming assignments in the first Computer Science course. The term “requirements specifications” is used here to refer to a description of the functional interaction of a single computer program with its environment and the non-functional constraints placed on that interaction. The principle thrust of the arguments is that students are best served if they are introduced to program design only as an activity which naturally follows requirements specification. This concept must be reinforced in all classroom examples and by practical student exercises. By requiring the students to create requirements specifications, the instructor encourages them to view the software development effort, from the beginning, as the analysis and solution of a problem rather than as the generation of a computer program. They are similarly encouraged to realize that the valuable end product of the effort is not just a program, but a thorough description of the problem and solution. Guidelines for incorporating the concept into existing CS1 courses are given. They are reinforced by a description of how this has been done in a specific course.
Development and documentation of computer programs in undergraduate computer science programs
Authors: Deneen Linda L. , Pierce Keith R.
Published: July 2004

Until recently, introductory programming classes in the Department of Computer Science, University of Minnesota, Duluth, concentrated on writing code. Not until the junior or senior year were students required to adhere to basic principles of software engineering. As might be expected, by their junior year students' bad habits, like coding while designing or inserting comments last, were firmly entrenched and difficult, if not impossible, to undo.

The solution, it seemed to us, was to prevent bad habits right from the start. Consequently, we developed guidelines for designing and documenting the entire programming effort, from problem statement to post mortem. The guidelines include such steps as: algorithm development in high-level pseudocode with stepwise refinements, structure diagrams with data flow, detailed test descriptions, testing results, and a description of all known bugs. For a given assignment, the instructor chooses the steps to be completed, allowing for flexibility and appropriateness in the design and documentation.

Results have been extremely positive. Students start earlier and produce better organized solutions. More students solve the problems correctly. Most importantly, students develop design and documentation skills in the freshman year that carry through and are improved over their four-year stay. Because of this initial success, our department has adopted these guidelines uniformly in all programming classes.

In this paper we will describe our guidelines and give some details of their use. We will discuss the philosophy that led us to develop these guidelines and present our observations of their effectiveness.
Understanding concurrent programming through program animation
Authors: Zimmermann M. , Perrenoud F. , Schiper A.
Published: July 2004

Program animation has mainly been developed for sequential programs. Animation of concurrent programs is much more uncommon, mainly because of the important technical problems. This paper presents a project whose objective is to animate any concurrent program written in the language Portal, a real time language close to Modula. The usefulness of animation in the context of teaching is shown by a few examples.
An introduction to the parallel distributed processing model of cognition and some examples of how it is changing the teaching of artificial intelligence
Authors: Whitson George M.
Published: July 2004

Artificial Intelligence programming involves representing knowledge, using paradigms to manipulate the knowledge, and having a learning process modify both the knowledge and the paradigms. One could consider this process as building a model of how one thinks, i.e. how the brain operates at the cognitive psychology level [2]. Recently, cognitive scientists have developed a model of how one thinks at the neural level. This model is called the Parallel Distributed Processing (PDP) model of cognition and is described in the definitive work of Rumelhart and McClelland [1]. The idea that we can actually model the brain as an electrical network of neurons and then develop Artificial Intelligence in terms of the model is extremely attractive. The program has had some success, especially in the area of sensory perception and motor activity, but still has some problems to overcome before it can be said to be the ideal foundation for Artificial Intelligence.

Much of the power of the PDP model derives from the learning algorithms. In this paper we consider a classification of learning algorithms that helps to organize the many developing techniques seen in the literature. We also discuss how the PDP model is changing the way we teach Artificial Intelligence. This is an important aspect of the PDP model, since the model has produced a number of new problem-solving techniques for Artificial Intelligence as well as holding out the promise of a better foundation for the basic theory of this field. If the PDP model fulfills its promise we would develop Artificial Intelligence programs that are really intelligent rather than programs that only appear to be intelligent.
Program complexity: a tutorial
Authors: Finkel David , Haggard Gary
Published: July 2004

How does a programmer decide which of two different algorithms to use to solve a problem? This is a particularly difficult question because one finds that often one part of the solution of a problem “dominates” the running time of the solution, i.e. uses a large fraction of the execution time. Further, this special part of the solution requires the programmer to choose an algorithm for its solution from a large number of alternatives. This tutorial describes one approach used in computer science to measure the complexity of a program by modeling programs with mathematical functions that describe their execution time. We break the solution of this problem into three parts. We first discuss the notion of how two
functions
are compared. We then show how algorithms can have their execution time modeled by functions. Finally, we see how to compare algorithms by comparing the functions that describe them.
Introducing knowledge-based projects in a systems development course
Authors: Kanabar Vijay
Published: July 2004

Due to recent advances in knowledge-based systems technology it is suggested that students in a systems development course be given exposure to the concept of designing and implementing knowledge-based systems.

The purpose of this paper is to describe the objective, scope, methods and procedures of knowledge-based projects. The first half of the paper introduces the knowledge-based approach and describes the structure and components of such a system. The second half of the paper deals with course design procedures. The scope, topics, project characteristics and experiences pertaining to such a project are covered here.

A practical Knowledge-based Systems Development Life Cycle (KSDLC) is also proposed for use in such a course. It is a suitable methodology as it resembles the traditional Systems Development Life Cycle.
Anatomy of a software engineering project
Authors: Bullard Catherine L. , Caldwell Inez , Harrell James , Hinkle Cis , Offutt A. Jefferson
Published: July 2004

This paper discusses a complete software development project carried out in a one quarter undergraduate software engineering course. The project was the design and implementation of a complete system by 25 students. They worked in smaller groups on four functionally separate subsystems that were successfully integrated into a complete system. This was accomplished by using five advanced students to manage the groups, real users to criticize each step of the process, and UNIX tools to implement the subsystems. This paper describes the project, presents the methodologies used, and discusses both the positive and negative aspects of this course. It concludes by presenting a set of recommendations based on our experience with this project.
The role of supercomputers in higher education
Authors: Neal Larry , Connolly John , Knight Doyle D. , Matthews-Morgan David
Published: July 2004

Advanced technology and networks have made the extra computational power of supercomputers affordable and accessible to researchers even at small universities. This panel will discuss how these important research tools can best be utilized in today's higher education environment.
Computer science undergraduate capstone course
Authors: Fuelling Clinton P. , Lancaster Anne-Marie , Kertstetter Mark C. , Roth R. Waldo , Brown William A. , Reidenbach Richard K. , Wongsawatgul Ekawan
Published: July 2004

Curriculum concerns of the computer science discipline continue to require refinements in this rapidly changing field. We have established curriculum guidelines and we have two years experience in the accrediting process of the CSAB. Remarks such as “I do not consider the topic of … to be in the computer science discipline” and “At least the topic of … is not a capstone course” are being made. The goal of this panel is to provide an open, probing platform for a discussion of the subject of a capstone course.
Application frameworks: experience with MacApp
Authors: Pugh John R. , Leung Cafee
Published: July 2004

It is an unfortunate truth that as personal computers have become easier to use they also have become more difficult to program. Students who want to write programs that look and feel like real Macintosh applications, for example, are constrained by the time available and the sheer complexity of the application development process. We have found that several object-oriented programming systems have succeeded in abstracting out the commonalties of graphical user interfaces and can allow students to construct interactive, graphical applications at a lower cost. In this paper we describe our experiences in the use of MacApp, an application framework for the Apple Macintosh. The design and implementation of Prof, a prototype visual programming system for both educators and students developed by a final year student in a thirteen week project course, is used to illustrate the discussion. We describe the advantages and disadvantages of the object-oriented application framework approach in the expectation that our experiences will be useful for other educators who may be contemplating following this path
.
Using assembly language to teach concepts in the introductory course
Authors: Donahue Barry
Published: July 2004

While current trends in the teaching of the introductory course are very positive, several problems still remain to be faced. Among these are:

A basic understanding of the operation of a computer.

An emphasis on concept development rather than skill development.

A proper historical perspective of computer science.

To help remove these deficiencies, a very simple virtual machine is introduced. Beginning students learn to program on this machine with a very limited instruction set. Many topics related to software engineering, data structures, algorithm design, etc. are introduced in a top down fashion with details being developed with the aid of the virtual machine. When a high level language is introduced, students progress more rapidly and with a greater understanding of what is taking place in the machine. Students also develop a feel for computer science as a dynamic field and tend not to think of a particular language as being what computer science is.
Recruiting more computer science students—what to do after the “glamour” has gone away?
Authors: McBride William E. , Calhoun James , Richards James L. , Taylor Harriet G. , Walters F. Garnet
Published: July 2004

The moderator will first focus on the question: “Are enrollments actually declining in computer science programs across this country?” He will report the results of his surveys which indicate there has been a definite downturn in enrollment over the past two years. The panelists will then discuss what is being done at their schools to recruit students and to meet this new challenge of declining enrollments.
A transition from bubble to shell sort
Authors: Klerlein Joseph B. , Fullbright Curtis
Published: July 2004

This paper describes a sorting method obtained by modifying bubble sort. This new sort, while still inefficient, sets the stage for Shell sort. It also raises some interesting questions which students can investigate.
Should short, relatively complex algorithms be taught using both graphical and verbal methods? Six replications
Authors: Scanlan David
Published: July 2004

This research investigates the preference for a graphical method (structured flowcharts) or for a verbal method (pseudocode) when learning short, relatively complex algorithms. The research summarizes the data from 6 replications using 193 students of data structures and 16 data structures classes. A preference for flowcharts was hypothesized under eight conditions. All eight conditions produced large differences which were statistically significant,
p
< .0001. The preferences for flowcharts ranged from 75.1% to 89.1%. No significant preferences were found for pseudocode. The results indicate that graphical methods should be strongly considered when teaching relatively complex algorithms. Most importantly, the results signify that there may be two types of learners: (1) a type which prefers flowcharts (a graphical method) and (2) a type which prefers pseudocode (a verbal method). Since most textbooks only express algorithms verbally, one must question the wisdom for using only one method.
Teaching database using a real DBMS: experience with INGRES
Authors: Haas David F.
Published: July 2004

This paper discusses the advantages of using a large, relational database system in a database course and describes in detail a course that has been taught at UW Oshkosh using INGRES as a vehicle for instruction.
A “course” for data modelling
Authors: King Ronald S.
Published: July 2004

What direction or path of learning should data modelling take? This author suggests a “
course
” for data modelling to follow. Artificial intelligence, databases, and programming languages are attempting to meet demands requiring a higher level of conceptual thinking than ever before. Likewise special tools and techniques are needed for that level of thought. Therefore data modelling methodologies are designed to provide an abstract level of system descriptions. A course based upon the comparative study of these various data modelling principles is described in this paper. This course stresses a transition from intuitive to formal development of data models. Such an approach facilitates the investigation of the concept of equivalence for data models, application models, and operations defined on data models.
An intelligent tutor for normal form determination
Authors: Becker Lee A. , Huang Xiaoyi
Published: July 2004

In this paper an intelligent computer-aided instruction system for teaching normal form determination is described. The general architecture of intelligent tutoring systems is also discussed, as are the results of experience using the tool in an undergraduate database course.
The computer background of incoming freshman: looking for emerging trends
Authors: Harrington Jan L.
Published: July 2004

As part of a longitudinal study begun in 1985, incoming Bentley College freshmen were asked to complete questionnaires about their pre-college computer experience. Although nearly all students came from high schools with computers and more than 80% of them had studied BASIC, just under half had used a word processor. Even fewer (less than 20%) had used either a spreadsheet or a database management system, though the actual percentage has risen over the three years for which data exist. The increase in the number of schools teaching Pascal noticed between 1984 and 1985 persisted in 1986. However, though nearly 46% of the schools from which 1986 graduates came taught Pascal, only half that percentage actually studied the language. Almost half the students used computers outside school during their high school years, but most of that use involved playing games.
Program plagiarism revisited: current issues and approaches
Authors: Summers Marguerite K. , Evans William B. , Fletcher James J. , Hanchey Cindy , Waguespack Leslie J.
Published: July 2004

Since the first courses were offered in programming, plagiarism has been a perplexing problem. Detection techniques, administrative procedures, and penalties vary greatly. Instructors face an increasingly legalistic system when prosecuting plagiarism cases. Panel members will discuss the prevention, detection, and prosecution aspects of program plagiarism and will present legal and administrative views of the problem.
A microcomputer oriented computer literacy course
Authors: Clarke Alice L. , Adkins Gerald W.
Published: July 2004

The development of a computer literacy course at the University of Georgia is described. Demographic information regarding students taking the class is provided. The course consists of two main parts:

1) microcomputer lab sessions devoted to working with word processing, spreadsheet, and data base software and to programming in BASIC; and

2) readings in a course text and viewing of telecourse tapes.

Course content and testing procedures are described in detail. How the course is changing with time and experience is also discussed.
Using concept expansion and level integration in an introductory computer science course
Authors: Kurtz Barry L. , Adams J. Mack
Published: July 2004

An introduction to computer science is supposed to teach problem solving and programming skills, but far too often only the latter is emphasized. One reason for this is the organization of texts by syntactic categories for a particular programming language. We report on an approach that uses concept expansion (expanding a concept from its simple form to more complex forms as needed to aid in problem solving) and level integration (combining several concepts at the same level of difficulty). Three detailed examples are given: flow of control, recursion, and information hiding. We have been using this approach at New Mexico State for the last two years and have found it to be helpful in restoring the intended balance between problem solving and acquiring programming skills.
Teaching programming: a new approach based on analysis skills
Authors: Pratt Terrence W.
Published: July 2004

A new approach is described to the teaching of introductory computer programming and computer science (the CS1 course). The approach is based on a new view of what “programming” is fundamentally about. The central feature of the approach is the teaching of skills in
program analysis
along with the traditional emphasis on skills in
program synthesis
. The approach was class tested in an earlier version in 1986, and the difficulties encountered in the class test led to two supporting changes in the course content: (1)
data structures
are introduced at the beginning of the course, and (2) the concept of
program state
is introduced as a key element in understanding programs.
Modeling in Prolog
Authors: Najarian John
Published: July 2004

Logic programming languages require a careful, incremental presentation in order to be understood by students of the standard von Neumann programming languages. In this paper, the characteristics and programming methodology of PROLOG are developed through a sequence of logic-oriented problems of increasing complexity. These activities are essential to fully understanding the mechanisms and internal behavior of this language and A.I. applications programs in general. In this approach, students are more motivated toward non-procedural logic. Even the problems alone have long been a source of interest in academic circles.
An amazing exercise in recursion for CS1 and CS2
Authors: Liss Ivan B. , McMillan Thomas C.
Published: July 2004

This paper describes an exercise which has been used in both CS1 and CS2 courses for the purpose of introducing the concepts of recursion and stacks, and for illustrating the benefits of procedural abstraction. The problem is to write a program which finds a path through a rectangular maze. The exercise is used in CS1 as part of an introduction to recursion. In CS2, it is used to illustrate and employ the abstract data type “stack.” In both exercises, the ideas are presented so as to reinforce the concepts of top-down design, and procedural and data abstraction.
Using a model railroad to teach digital process control
Authors: McCormick John W.
Published: July 2004

This paper describes experiences with a course designed to introduce undergraduate students to the design and implementation of real-time systems for the monitoring and control of laboratory and industrial processes. A model railroad is suggested as an inexpensive process to control. A variety of laboratory exercises involving such a model railroad are presented.
Microprogramming a watch: tools for a course in computer organization
Authors: von Kaenel Pierre A.
Published: July 2004

This paper describes a software simulator of a digital watch programmable at the microprogram level and used for instructional purposes in a computer organization course. A special editor for writing microcode is also introduced.
Visual simulation of finite state machines
Authors: Jagielski Romauld
Published: July 2004

A system for a graphic simulation of finite-state machines is presented. The system helps to define a finite-state automaton and a graphic representation of it. It also facilitates understanding and testing of finite-state machines. The system is designed to be used by under-graduate computer science students as an aid in units such as Compilers and Theory of Computation.
Programmatic efforts encouraging women to enter the information technology workforce
Authors: Wardle Caroline , Burton Lawrence
Published: July 2004

For over a decade the National Science Foundation (NSF) has been supporting projects designed to improve opportunities for women in computing. From an initial emphasis on increasing the number of women in graduate school studying computer science and engineering, NSF's current emphasis has broadened to include research studies examining the underlying reasons why women are underrepresented in the information technology (IT) workforce. This paper describes the recent history of NSF's activities in this area and the subsequent emergence of a research portfolio addressing the underrepresentation issue.
People who make a difference
Authors: Townsend Gloria Childress
Published: July 2004

The literature of gender issues in computing steadfastly and uniformly has advocated the use of mentors and role models (M&RM) for recruiting and retaining women in computer science [3, 17, 20.] This paper, therefore, accepts the results of research studies and avoids reiterating details of the projects but offers instead a practical guide for using M&RM to recruit and retain women in computer science. The guide provides pragmatic advice, describing several different facets of the M&RM concept.
Support communities for women in computing
Authors: Gabbert Paula , Meeker Paige H.
Published: July 2004

This article highlights the many activities provided by the support communities available for women in computing. Thousands of women actively participate in these programs and they receive many benefits including networking and professional support. In addition, the organizations and associations help promote the accomplishments of women computer scientists and disseminate valuable information. This article surveys some of these organizations and concludes with a list of suggestions for how faculty members can incorporate the benefits of these organizations in their own institutions.
Unlocking the clubhouse
Authors: Fisher Allan , Margolis Jane
Published: July 2004

In the fall of 1995, just seven of 95 students entering the undergraduate program in computer science at Carnegie Mellon University were women. In 2000, 54 of 130, or 42%, were women. What happened? This article presents a brief history of the transformation at Carnegie Mellon's School of Computer Science, and the research project that lay behind it. A fuller discussion, set in an analysis of gender issues in computing from childhood through college, is found in our book,
Unlocking the Clubhouse: Women in Computing
[2].The story begins with a research study designed specifically to diagnose and find remedies for the gender gap in Carnegie Mellon's undergraduate computer science program. Female enrollment had hovered below 10% for a number of years, and the fraction of women leaving the program was approximately twice that for men. In 1995, the Alfred P. Sloan Foundation funded our proposal for a two-year program, which was followed up two years later with a two-year extension. The goal was to understand the experiences and choices of both men and women with respect to studying computer science, and to design interventions that would involve more women.
Encouraging women in computer science
Authors: Roberts Eric S. , Kassianidou Marina , Irani Lilly
Published: July 2004

At a cost to both their own opportunities and society's ability to produce people with much-needed technical skills, women continue to be underrepresented in computer science degree programs at both the undergraduate and graduate level. Although some of the barriers that women face have their foundations in cultural expectations established well before the college level, we believe that departments can take effective steps to increase recruitment and retention of women students. This paper describes several strategies we have adopted at Stanford over the past decade.