bluuebunny/crossref_metadata_2025 huggingface dataset:
What can we learn by testing a program?
Authors: Hamlet Dick
Published: July 2004

It is conventional to start research papers on software engineering, particularly on testing and software quality, with a statement of how important software has become in the world, and the potential dangers of using it when those who construct it really don't know what they are doing. The author then goes on to show that his or her theory/method/insights/tools will make the world safe (or safer, if the author is modest) by providing the understanding that is lacking. ISSTA authors (I among them) have started many of their papers in just this way, but speaking for myself, these statements are window dressing --- they disguise my real concern. Long before software was any part of the workaday world, before there was any "software problem" or even much software, I was interested in program analysis because programs are arguably the most intriguing mathematical objects people create. I have happily pursued the study of programs for over 30 years.I wrote my first program (in ALGOL 58) in 1962 --- it failed to properly calculate a table of values of the error integral, being somewhat off in the third significant figure. (I remember the failure, and the debugging, poring over a decimal memory dump. But I can't recall the fault.) It took me until the mid-1960s to recognize that programs
per se
were much more interesting than their applications: I stumbled on Maurice Halstead's book [4] on self-compiling NELIAC compilers. Here was magical stuff: the master program defining a language, and itself written in that language! In my application to the University of Washington, I explained that I wanted to study computers "for themselves, not as they are used." Paul Klee, the topologist who was saddled with the task of replying to mathematics grad students that year, wrote back to assure me that "we've got a computer around here somewhere, and by the time you arrive I'm sure I can locate it." It was an IBM 7090, complete with IBSYS and FORTRAN, and who could have asked for software more in need of analysis?There were standards of respectability for a PhD dissertation even in those days, so I took up recursive function theory and the program-equivalence problem. Its application to testing is that we would like to know if the program under test differs from its functional specification --- that is, can it fail? Any understanding of programs through testing (a mechanical process) must come up against the program-equivalence problem: we cannot hope to gain full understanding, because to do so would be to solve the unsolvable problem. My dissertation was an exploration of the additional information (beyond the purely functional) needed to make the program-equivalence problem solvable [5]. What brought me to the first ISSTA in 1978 was Bill Howden's 1976 paper "Reliability of the path analysis strategy" [6].
Automatic interoperability test generation for source-to-source translators
Authors: Molloy Mark , Andrews Kristy , Herren James , Cutler David , Del Vigna Paul
Published: July 2004

This paper describes a strategy for automatically generating tests which ensure interface compatibility between software components expressed in two different languages. This strategy is useful for testing code produced by a source-to-source computer language translator and for testing the compatibility of compilers for the different languages.
Verifying systems with integer constraints and Boolean predicates
Authors: Bultan Tevfik , Gerber Richard , League Christopher
Published: July 2004

Symbolic mode, checking has proved highly successful for large finite-state systems, in which states can be compactly encoded using binary decision diagrams (BDDs) or their variants. The inherent limitation of this approach is that it cannot be applied to systems with an infinite number of states --- even those with a single unbounded integer.Alternatively, we recently proposed a model checker for integer-based systems that uses Presburger constraints as the underlying state representation. While this approach easily verified some subtle, infinite-state concurrency problems, it proved inefficient in its treatment of Boolean and (unordered) enumerated types --- which possess no natural mapping to the Euclidean coordinate space.In this paper we describe a model checker which combines the strengths of both approaches. We use a composite model, in which a formula's valuations are encoded in a mixed BDD-Presburger form, depending on the variables used. We demonstrate our technique's effectiveness on a nontrivial requirements specification, which includes a mixture of Booleans, integers and enumerated types.
All-du-path coverage for parallel programs
Authors: Yang Cheer-Sun D. , Souter Amie L. , Pollock Lori L.
Published: July 2004

One significant challenge in bringing the power of parallel machines to application programmers is providing them with a suite of software tools similar to the tools that sequential programmers currently utilize. In particular, automatic or semi-automatic testing tools for parallel programs are lacking. This paper describes our work in automatic generation of all-du-paths for testing parallel programs. Our goal is to demonstrate that, with some extension, sequential test data adequacy criteria are still applicable to parallel program testing. The concepts and algorithms in this paper have been incorporated as the foundation of our DELaware PArallel Software Testing Aid,
della pasta.
REFSQ'97 workshop summary
Authors: Dubois Eric , Opdahl Andreas L. , Pohl Klaus
Published: July 2004

The REFSQ (Requirements Engineering: Foundation for Software Quality) 1997 workshop was held in conjunction with CAiSE'97 in Barcelona, Spain on June 16th and 17th, 1997. It was organised by Eric Dubois, Andreas L. Opdahl and Klaus Pohl. In this workshop summary we, the organisers, will provide an overview of the workshop and of the presentations given, and present our subjective view of the various and fruitful discussions that took place.
A framework for encapsulating card-oriented, interactive, legacy applications
Authors: Butkus Al , Mitchell Barbara L.
Published: July 2004

Over the last several years Lockheed Martin has invested IR&D funds to explore lowering the cost of ownership of Command and Control systems for DoD software intensive systems. Two key technologies that address this issue are developing software components that can be reused across a family of systems within the command and control domain and methods for reusing legacy system applications. This paper describes how these two approaches have been merged using Object Oriented Technology to provide a reusable framework for encapsulating legacy applications.The Object Oriented Technology (OOT) that we consider key to lowering cost of ownership and to strategies for reuse of legacy code is described as Design Patterns [Gamma] and Frameworks[Coplien]. Design Patterns exist at a level of abstraction that provides a high return on reuse investment because they model stable relationships that are not likely to change as a system evolves and which can be reused across systems [Coplien]. It is not the intent of this paper to describe these terms. Rather it is our purpose to illustrate the advantages of this level of OOT.
Making active CASE tools—
toward the next generation CASE tools
Authors: Huang Riri
Published: July 2004

In CASE field, there is a long-standing topic, i.e. the reason that CASE tools seem to be dearly bought but sparsely used. Based on our practical experience of making and using CASE tools, we point out the reason is that today's CASE tools are actually not very much user-oriented. The factors and requirements of CASE users are not given enough consideration in the production of CASE tools. Most today's CASE tools are motivated by new paradigms and techniques in the area of software engineering. Therefore, making CASE tools are often driven by techniques, rather than by real users' needs and expectations. In this paper, we present our viewpoints on the reason why CASE tools are used below expectations. We suggest some important features that are worthy of careful consideration while producing more people-oriented and active CASE tools. We also describe some strategies for building such CASE tools.
Integration of complexity metrics with the use of decision trees
Authors: Kokol Peter , Brest Janez , Zorman Milan , Podgorelec Vili
Published: July 2004

We would like to present the use of the decision tree approach in the integration of various complexity metrics on the example of distinguishing between random and ordinary programs. Following our proposition that randomness indicates meaningless we can state that with the approach we are able to measure the "meaning" of computer programs. The main contributions stated in the paper is that the new way of metrics integration enabling one to combine metrics with various measurement units.
Generalization of leaner object-oriented slicing
Authors: Law Rob
Published: July 2004

The Leaner Object-Oriented Slicing technique in [2], albeit effective in providing further code reduction from an object-oriented slice, fails to handle an object-oriented slice with multiple inheritance nets. That is, an object-oriented slice in a tree form with multiple branches is beyond the ability of leaner object-oriented slicing. This paper proposes a new approach which extends the applicability of code reduction by leaner object-oriented slicing. A generalized leaner object-oriented slicing method can now be achieved which provides further code reduction for general object-oriented slices.
Interacting with Object-Oriented Program Slicing
Authors: Law Rob
Published: July 2004

Object-Oriented Program Slicing was introduced by Law and Maguire [1,2]. On the basis of Object-Oriented Program Slicing, C++ Object-Oriented Program Slicer [C++_OOPS] was developed to assist programmers locate program faults. Technical investigation of Object-Oriented Program Slicing and the design of C++_OOPS can be found in [1,2]. This paper provides a discussion and analysis of programmers' views towards using C++_OOPS. Users generally agree that C++_OOPS assists high-level debugging, yet a more user-friendly C++_OOPS environment could definitely be more beneficial.
Holistic design of a programming system
Authors: Anane R.
Published: July 2004

The different stages of the prevailing software development model involve the use of software development tools and methods that are usually based on different paradigms. The mismatch between the different levels of this hierarchical process is often a source of difficulty and has led to an increasing interest in the holistic approach to software design and implementation. This approach requires all the levels to be based on the same principles. This paper describes how it was used in the design and implementation of a small programming system which incorporates a functional language, an optimiser and a syntax-directed editor. It also highlights the advantages of the holistic approach.
Two-dimensional software development model combining object-oriented method with formal method
Authors: Xiaodong Yuan , Jiajun Chen , Guoliang Zheng
Published: July 2004

Most of current software development models are linear, one-dimensional model. On the basis of the analysis of the current models, this paper provides a two-dimensional software development model that combines object-oriented method with formal method. This model has the advantages of both methods. We introduce three key stages of the model architecture in details
Software agents and intelligent object fusion
Authors: Nourani Cyrus F.
Published: July 2004

Techniques for modular software design are presented applying
software agents.
The conceptual designs are domain independent and make use of specific domain aspects applying
Multiagent AI.
The stages of conceptualization, design and implementation are defined by new techniques coordinated by objects. Software systems are designed by knowledge acquisition, specification, and multiagent implementations. Multiagent implementations are defined for the modular designs, applying our recent projects which have lead to fault tolerant AI systems. A novel multi-kernel design technique is presented.Communicating pairs of kernels, each defining a part of the system, are specified by object-coobject super-modules. Treating objects as abstract data types and a two level programming approach to OOP allows us to define Pull-up abstractions to treat incompatible objects.
Keywords
Abstract Objects, Intelligent syntax, MJOOP, Multi Agent Object Level Programming, Multi Kernel Design With OOP, Software Agents, Intelligent Objects. Academic UCSB when at University
An interactive learning environment for breadth-first computing science curriculum
Authors: Palakal Mathew J. , Myers Frederick W. , Boyd Carla L.
Published: July 2004

Developing a learning suppliment to support the breadth-first computer science curriculum and taking advantage of emerging technologies to provide interactive, demand-driven simulations which enhance comprehension of abstract concepts in computer science resulted in the PACER (Personally Active Computing Exploration Resource) project. Development of this educational tool includes three fundamental objectives: simulation and experimentation, connection to supplementary information, and delivery to a wide audience across multiple computer platforms. All three objectives are required to support the educational demands of students who struggle with difficult theoretical material, seek access to information round-the-clock from home and work and use a variety of computer platforms. The PACER system meets learners' needs of repetition and visual simulation of complex ideas. It also offers the ability to pursue education from remote locations making accessible resources never before available. The interactive design of PACER encourages self-directed learning. It also challenges and supports commuting adults, students with disabilities, and traditional students to pursue fields of quantitative reasoning. Unlike traditional WWW-based learning environments, the PACER pages support interactive learning sessions as well as simulations with animation capabilities. The hierarchical organization of Web pages allows the PACER system to have learning modules that are inter-linked which in turn supports "demand-driven" learning. This feature allows PACER to be an active learning tool.
Computer science degree programs
Authors: McCauley Renée , Manaris Bill
Published: July 2004

This paper presents information from a survey of departments offering accredited computer science degree programs. It discusses demographic information related to curricula, faculty, and students for all such programs, and identifies various trends based on these data. These results are of interest and use to all accredited and non-accredited programs alike, since they facilitate monitoring and comparisons among individual degree programs in the nation in terms of curriculum issues, faculty composition and salaries, student enrollment and graduation rates.
Giving computer science students real-world experience
Authors: Villarreal E. E. , Butler Dennis
Published: July 2004

Class assignments should have more relevance to the real world. There is not enough time to have a realistic project in a class, but a realistic project would give the students a taste of the real world.We attacked this problem by merging two classes, Introduction to Database Systems and Software Engineering I, thereby allowing enough time for a more meaningful final project. We chose to use a loosely coupled approach to merging our classes.
Network monitoring system design
Authors: Barr Bob , Yoo Sung , Cheatham Tom
Published: July 2004

Computer networks can be very useful, but difficult to manage. Current network management tools tend to be either very expensive or inadequate for classroom modification. XSNIFF is a project to develop an alternative network monitoring tool with a graphical display in the X-Window environment. XSNIFF uses an efficient network packet filtering system developed by Jacobson, Leres, and McCanne of Lawrence Berkeley Laboratory[Jacobson, 1994], to receive all network traffic from the network wire and then translate it into usable information. The network listening device should not affect the normal flow of network traffic, but should observe it. XSNIFF has a graphical interface that allows the user to select between statistical information and a TCP connection graph. The statistical information displays data belonging to different network level protocols and different user level protocols. The connection information is displayed as a graph showing which network nodes are connected to what other nodes. The information can be used by a teacher in a computer network class to help students visualize network traffic and as a learning tool to help students understand computer network protocols.
Resources for teaching computer networks
Authors: Lankewicz Linda B.
Published: July 2004

Teaching a computer networks course can be a challenge both in terms of deciding on the focus of the course and providing appropriate practical experiences to complement the theoretical issues. However, because the course overlaps other areas of the computer science curriculum, it is an opportunity to apply some of the concepts from other areas and to expose students to the research in the field. This paper describes a computer networks course to accomplish this along with a collection of resources.
Computer scientists can teach writing
Authors: Kay David G.
Published: July 2004

The author's institution requires all students to take one course that concentrates on writing at the upper division (junior or senior) level. The computer science department offers one such course, taught by computer scientists. It concentrates on communications issues relevant to computer scientists and computer professionals, going beyond traditional "technical writing" to give students experience in oral presentation, document design, and writing in forms appropriate for various audiences. This course takes advantage of analogies between writing and software development and motivates computer science students to pay more careful attention to their writing.
Towards a hierarchical design and integration of programming projects
Authors: Li Wing-Ning
Published: July 2004

The idea of a hierarchical design and integration of programming projects in the computer science undergraduate curriculum is proposed and discussed. Research results in software reuse and object-oriented design and development may be used in the design and the development of the set of integrated programming projects. By a hierarchical design and integration of programming projects, this approach aims to increase the effectiveness of the undergraduate learning experience. Using the approach, programming projects in computer science courses may be developed in such a way that programming projects in the lower level courses are used as components (parts) to implement programming projects in the higher level courses. In this way, a hierarchical structure of programming projects can be built and a student's programming projects in different courses can be integrated. Such an integration may lead to the development of complex software systems in the senior year.
The ExCon project
Authors: Nuldén Urban
Published: July 2004

In this paper it is claimed that traditional examination often is destructive to the process of learning. It does not matter how good intentions educators have, it is the way they examine students that will have the strongest impact on how the students learn. The goal of the ExCon project is intervention in traditional examination. The paper discusses an alternative model for understanding assessment and examination of students. Product assessment is questioned as an appropriate approach. Instead it is argued that educators should, to a larger extent, provide the student with questions and other types of feedback during the ongoing activity and use communication as an important element of the examination. For this purpose, a software prototype for a mobile computing device to support the educator was designed and developed. An evaluation of the prototype was performed and the paper ends with some thoughts on the viability of the prototype in supporting alternative assessment and examination.
Integrating technology into computer science examinations
Authors: Mason David V. , Woit Denise M.
Published: July 2004

On-line programming tests and examinations were administered to approximately 120 first year computer science students in order to evaluate their practical skills. We describe our motivation for on-line testing, outline the technical details of our closed testing environment, and present our observations about student performance. We also compare the effectiveness of on-line tests versus conventional tests, report the problems we encountered and our solutions, relate student opinion regarding the on-line testing experiment, and present some insights gained by this experiment.
Design patterns
Authors: Astrachan Owen , Mitchener Garrett , Berry Geoffrey , Cox Landon
Published: July 2004

The field of software patterns has seen an explosion in interest in the last three years. Work to date has been on the recognition, cataloging, and finding of patterns with little attention to the
use
of patterns, especially by students and practitioners not well-versed in object-oriented technologies. This project addresses pattern use through the development of several programming and pedagogical frameworks that supply support for using patterns throughout a computer science curriculum. Although we do not claim that patterns are Brooks' silver bullet [10], their use can help cope with the accidental complexity of software development and, we argue, their use is essential for a successful adoption of object-oriented techniques in academic computer science programs. This project addresses practical concerns of the computer science and software engineering communities in using, teaching, and learning patterns. In this paper we argue that patterns are an essential programming and pedagogical tool and report on our work in making them accessible to the educational community.
Average-case analysis in an elementary course on algorithms
Authors: Ferri Francesc J. , Albert Jesús
Published: July 2004

Average-case algorithm analysis is usually viewed as a tough subject by students in the first courses in Computer Science. Traditionally, these topics are fully developed in advanced courses with a clear mathematical orientation. The work presented here is not an alternative to this, but, it presents the analysis of algorithms (and average-case in particular) adapted to the mathematical background of students in an elementary course on Algorithms or Programming by using some specially selected examples.
Tools for Web-based sorting animation
Authors: Dershem Herbert L. , Brummund Peter
Published: July 2004

There is a long and rich tradition of sort algorithm animations that have been used effectively in instruction. This paper describes a new tool that combines the best of this tradition with the advantages of being in the form of an applet for use on the World Wide Web and of animating the code of the algorithm in concert with the animation of the data. In addition, this tool facilitates student-designed animations that are useful for the debugging of student-written sort algorithms. Recursive sort algorithms are made more accessible through the use of a special feature of the tool that animates the recursion.
FCLUST
Authors: Egan M. A. , Krishnamoorthy M. , Rajan K.
Published: July 2004

Emerging technologies on the World Wide Web promise to make program, algorithm and concept simulations universally accessible. Simulations involving animation and visualization have a tremendous benefit when applied to various algorithms. We present a simulation tool for experimenting with concepts in fuzzy clustering that has proved useful in visualizing the results and demonstrating the computation method of the algorithms. This is especially advantageous in a classroom or laboratory setting where students may become more comfortable with the mechanics of fuzzy clustering through personal discovery and online experimentation.
A system for program visualization in the classroom
Authors: Sangwan Raghvinder S. , Korsh James F. , LaFollette Paul S.
Published: July 2004

This paper describes the use of a system which will allow effortless visualization and animation of standard C/C++ programs. The system brings alive programs so that students in CS 1 and CS 2 classes can more easily see each instruction and its effects. They can also see the effects of larger entities such as functions. The system serves as an excellent instructional tool and debugger.
A multi-windowed environment for simultaneous visualization of related algorithms on the World Wide Web
Authors: Naps Thomas L. , Bressler Eric
Published: July 2004

Using algorithm visualization, we can depict the execution of an algorithm as a sequence of graphical snapshots, the viewing of which is controlled by the user. Although the delivery of such visualizations over the Web greatly increases their accessibility, Web-based environments for viewing algorithms often lack the richness of features that characterize similar viewing environments on standalone machines. Here we describe enhancements recently made to such a Web-based system. These enhancements conveniently present a variety of windowing options that allow the user to simultaneously view multiple snapshots. These snapshots may depict (1) similar views of the states of an algorithm over a range of time, (2) different views of the state of an algorithm at a given point in time, or (3) side-by-side comparisons of different algorithms that solve the same problem. We illustrate each of these options using variations of the quick sort algorithm.
Do lab modules in CS actually help students?
Authors: Tjaden Bunny J.
Published: July 2004

Three laboratory modules were developed to teach C pointers to novice programming students, using two different versions of software. The first version was an intelligent tutoring system; the second was a multimedia tutorial. Six classes of students participated in an empirical study involving both versions of software. What was discovered as a result of this experiment was more than just the answer to whether or not a particular piece of software helped the students to learn the subject matter. We discovered who used the software, given the freedom of choice. We learned about the characteristics of software users, which software was more helpful, and what the students think about using software to learn. The more significant results of this study are presented in this paper.
The effects of partially-individualized assignments on subsequent student performance
Authors: Toothman Brian , Shackelford Russell
Published: July 2004

At Georgia Tech, we investigated aspects of student performance in the
Introduction to Computing
course offered by the College of Computing. Our goal was to investigate the effects of customizing assignments based on individual student needs. This was motivated by the fact that our technology can enable us to create and distribute individualized assignments. Thus, we sought to answer the question, "In the span of a single academic quarter, can we (a) identify weaknesses in each student's performance, then (b) give them assignments targeted to their individual weaknesses such that (c) we achieve a positive impact on their subsequent performance. Significant results were found with respect to certain aspects of individualization. They suggest individualized assignments can be effective for students who evidence neither very strong nor very weak topical performance.
Developing integrated Web and database applications using JAVA applets and JDBC drivers
Authors: Yang Andrew , Linn James , Quadrato David
Published: July 2004

With the maturity of network technology, the deterministic factor of a 'successful' web site does not as much depend on its connectivity to the Internet, rather the content of web pages plays a more important role. The inclusion of dynamic data, for example, has become an increasingly desirable feature of a web page. Web servers that support dynamic web pages are capable of retrieving data at the time of user requests. Rather than being statically included in the web page, these dynamically retrieved data may physically reside in various file systems or database servers across the Internet.JAVA, a new object-oriented programming language, has become a buzzword since its introduction by Sun Microsystems in 1994 [1, 2, 3]. It was claimed that JAVA, via its ability to embed applets in a web page, would make the content of a web page alive and dynamic. Data and information on a web page can now be updated dynamically when users request them.In this paper, we discuss our experience of developing JAVA applets that use various types of JDBC (JAVA Database Connectivity) drivers to connect to and then manipulate data stored in SQL (Structured Query Language) database servers. We first start with the discussion of general client/server model involving JDBC, and then introducing the procedure of setting up programming projects employing this approach in an undergraduate database course.
Learning SQL with a computerized tutor
Authors: Mitrovic Antonija
Published: July 2004

SQL, the dominant database language, is a simple and highly structured language; yet, students have many difficulties learning it. This paper presents SQL-Tutor, an Intelligent Teaching System designed as a guided discovery learning environment, which helps students in overcoming these difficulties. We present design issues and the current state in the implementation of the system, with special focus on individualization of instruction towards a particular student.
Design patterns for data structures
Authors: Nguyen Dung
Published: July 2004

Design patterns provide ways to structure software components into systems that are flexible, extensible, and have a high degree of reusability. The state pattern, the null object pattern, and the singleton pattern are used to implement common data structures such as lists and trees. These patterns help narrow the gap between the abstract views of the data structures and their concrete implementations. The smaller the gap, the higher the level of abstraction. The more abstract, the less complex the coding structure. As a result, algorithms are easier to understand and more manageable. This paper advocates teaching the above design patterns in data structures courses.
Experience with an analytic approach to teaching programming languages
Authors: Haynes Christopher T.
Published: July 2004

Through the use of interpreters it is possible to teach programming languages in an analytic way without the mathematical overhead associated with other formal methods. This is a natural evolution of programming language pedagogy from present approaches that are largely descriptive. As a bonus, students receive training in the use of meta-linguistic abstraction in program design. An example of this approach is presented along with suggested variations and discussion of a number of practical considerations that may be crucial to success in the classroom.
Integration of mathematical topics in CS1 and CS2 (panel)
Authors: Tomer D. S. , Baldwin Doug , Fox Christopher J.
Published: July 2004

The purpose of this panel is to discuss the possibility of integration of the appropriate mathematical topics in the CS1 and CS2 courses. Practically, every university/institute offering an undergraduate program in computer science offers one or two courses in discrete mathematics for CS majors. It seems desirable to introduce some of these topics (discrete mathematics) in the beginning courses along with the programming concepts - so that, a student can appreciate (and use) the theoretical concepts as meaningful to the field of programming.At many places, a course on discrete mathematics is taught in an isolated manner with little emphasis of its topics in the earlier courses in computer science. In fact, this course is viewed as a mathematics requirement along with the other mathematics courses, such as calculus, linear algebra, and statistics etc. Many topics introduced in a discrete mathematics can be best utilized with CS1 and CS2 courses. Some instructors may teach CS1 and CS2 courses without any regard to the topics of discrete mathematics as applicable to CS1 and CS2. A course on discrete mathematics designed with a specific relevance to CS majors, should be integrated from the very beginning at freshman level. Furthermore, a course on discrete mathematics is offered at sophomore/junior level when a student has already completed many CS courses including CS1 and CS2. The most realistic prerequisite to CS1 is college algebra and it is unlikely that a incoming freshman is ready to handle traditional topics of discrete mathematics without some mathematical maturity (may be after calculus?). The session will begin with a brief presentation from each of the panelists, and then we will open the floor for general discussion and dabate. A survey about such an integration will be conducted from the audience in this session.
The future of programming—are fundamental changes in computer science programs coming? (panel)
Authors: Hart Hal , Caristi Jim , Dewar Robert , Gerhardt Mark , Hamilton Drew , Haynes Christopher , Rebelsky Sam
Published: July 2004

Computer programming languages (and their dominance as the means of software development) have been one of the most high-profile topics in the 50-year history of computing --- reaching mature technology and achievements for language definition, translation, usage, analysis, pedagogical approaches, etc. and in terms of their general impact on computing systems This reality has continuously driven the content of Computer Science curriculums to feature programming languages, their definition techniques, and their translation methods as the subject of many core courses, and their usage as a tool to carry out the teaching of the principles in most other courses. The objective of this panel is to, at just past the mid-point of the first century of computing, debate whether this pre-eminent role of programming languages will continue straightforwardly in the second half-century, if radically new styles of programming languages will emerge and dominate, or if programming languages will recede to minor importance compared to alternate software-development paradigms in both usage and teaching impact. And, for each of those propositions, to assess the impacts for change in typical CS curriculums.For most software domains today, so-called 3rd-generation programming languages (e.g., Ada, Scheme, Pascal, C/C++, Modula 2, COBOL, FORTRAN, and recently, Java) enjoy considerable portability between computers and are now widely accepted. In these "procedural" languages programmers still are responsible for designing and coding the software architectures, algorithms, logic, and most data structures to solve the problems. For some well-understood domains (e.g., report writing, inventory control, and some financial programming), 4th-generation languages (4GLs) or "non-procedural" languages are established which essentially allow users to specify "requirements" instead of software solutions, with 4GL compilers that generate code satisfying the requirements; the number of domains for which 4GLs are appropriate increases steadily as domain understanding increases. 5th-generation or automatic programming approaches have been a research topic for many years, with some promising results demonstrated in constrained domains, although the distinction from a 4GL to a 5th-generation language (5GL) is less clear than the earlier transitions. Technologies for formally representing and translating programming languages, and the concepts and methods for teaching their effective application, have continually evolved with the programming language trends, and are generally regarded in the body of crystallized core CS concepts.
Software documentation and readability
Authors: Haneef Nuzhat J.
Published: July 2004

The paper is based on the premise that the productivity and quality of software development and maintenance, particularly in large and long term projects, is related to software readability. Software readability depends on such things as coding conventions and system overview documentation. Existing mechanisms to ensure readability --- for example, peer reviews --- are not sufficient. The paper proposes that software organizations or projects institute a readability/documentation group, similar to a test or usability group. This group would be composed of programmers and would produce overview documentation and ensure code and documentation readability. The features and functions of this group are described. Its benefits and possible objections to it are discussed.
A “call for answers” around the proposition of an HCI-enriched model
Authors: Kolski Christophe
Published: July 2004

The engineering of Human-Computer Interface (HCI) is a wide-ranging and huge research field. However development models stemming from Software Engineering overlook important aspects in terms of interactive systems development. That is why an HCI-enriched model, called ∇ model (pronounced nabla model), is envisaged in this paper.
Inquiry-based computer science instruction
Authors: Abernethy Ken , Gabbert Paula , Treu Kevin
Published: July 2004

In computer science, as well as in other disciplines, it is critical to the success of the educational process that students become actively engaged with the material, rather than passive recipients of it. Ideally, this interaction will begin
before
the class meets on a particular topic, in a process known as
inquiry-based learning
. This paper describes some initial experiments with using technology to implement an inquiry-based learning paradigm.
Teaching computer science in Papua New Guinea
Authors: Bampton Alvin
Published: July 2004

This paper introduces some observed sociological and cultural aspects of students. It is usually assumed that these aspects are the same as the lecturer's own, but that is not necessarily so, here in Papua New Guinea. Assignments to encourage both the change of attitude and for the practice of the technical content of courses are described.
Web hosted assessment—possibilities and policy
Authors: Culwin Fintan
Published: July 2004

This paper presents a categorisation of Web hosted assessment systems and then uses this to produce an outline specification for a fully featured system, against which other systems can be evaluated. It concludes by considering the logistics of using such systems for summative assessment.
The problem of examination questions in algorithmics
Authors: de Marneffe P. A.
Published: July 2004

Algorithmics is a problem solving activity. Examination questions must reflect this nature of the domain. They must lead to open answers, but the specific criteria used in grading these answers must be clearly understood by the students. In this paper, we explain which criteria we use in the context of a course on algorithmics given to first year students in Informatics and in Engineering. Our experience shows that the teaching of very important topics in Computing Science can never be automated.
A constructivist learning environment implemented in Java
Authors: Gray John , Boyle Tom , Smith Colin
Published: July 2004

In this paper we describe the development of a flexible and interactive learning environment for studying the Java programming language. The system has been written using Java and has been designed around an extended version of the CORE [1] design methodology. Earlier work using CORE resulted in hypertext based learning environments such as CLEM (CORE Learning Environment for Modula-2) [2]. The current work seeks to enhance and augment the features provided in the early work by offering additional representations of the topics under study, incorporating audio and video resources, and improving the flexibility of the possible learning paths through the learning materials.
A participative approach to teaching programming
Authors: Jenkins Tony
Published: July 2004

In this paper, we describe an approach to the teaching of introductory programming to students with no previous experience of programming. The approach is based on the key idea of making students
active participants
in classes rather than
passive recipients
as might be the case when they are exposed to more traditional lecture-based teaching. In these classes the students are called upon to adopt the rôles of various components in a program and to "act out" relevant processes and procedures.We consider why such an approach might be effective and why it might be expected to be particularly effective in the area of introductory programming.The techniques described were developed and tested during the 1997/98 academic session in the School of Computer Studies at the University of Leeds. At the end of the presentation a brief evaluation was carried out.In conclusion we consider the effectiveness of the approach after a semester's experience and describe planned future developments.
Visual programming with Java
Authors: Kluit Peter G. , Sint Marleen , Wester Frank
Published: July 2004

During 1996/1997 the authors were involved in writing an introductory programming course for distance learning, based on Java and visual programming. In the fall of 1997 the course material was used both at the Dutch Open University and at Delft University of Technology. In this paper we report on our experiences in first using the course material.
A comparison between novice and experienced compiler users in a learning environment
Authors: Lewis Stuart , Mulley Gaius
Published: July 2004

A locally built Modula-2 compiler has been used for number of years in our School. The messages that are emitted from the compiler when run by first and final year students have been logged. Over the last two years we have been improving the usefulness of these messages. This paper presents an analysis of these results.
WWW-based presentations as a complementary part of conventional lectures in the basic of informatics
Authors: Makkonen Pekka
Published: July 2004

Hypertext and the WWW appear to affect learning positively. Both techniques enable the constructivistic learning environment to support a student's knowledge construction and a more active role of a student. However, the problems associated with them may endanger the positive effect on learning. Thus, the role of hypertext and the WWW must be discussed.Because of the common problems of "information overload" and "lost-in hyperspace", we suggest guided tours in the form of a slide show presentation as a solution to organise a hypermedia presentation on the WWW for the basics in informatics. These slides include links to the supporting web sites. In addition to guided tours, we also suggest that the use of search engines and directories must be promoted. This paper describes the use of the WWW-based guided tours as a complementary part of conventional lectures in the learning of the basics in informatics. We give reasons for our approach based on both discussion about the role of the WWW in learning and the results of our pre-questionnaire.
PRAM
Authors: Mansouri Fatima Z. , Gibbon Cleveland A. , Higgins Colin A.
Published: July 2004

Sometime during their academic career, most teachers will have to mark and assess students' work. A system that automatically marks students' work and gives instant feedback would be highly beneficial to both teachers and students alike. A Prolog automatic marker is described here for this purpose.
A secure networked laboratory for kernel programming
Authors: Mayo Jean , Kearns Phil
Published: July 2004

Recently, several flavours of UNIX have appeared which run on inexpensive personal computers. Further, the source code for these operating systems is freely available. This makes offering courses that include realistic kernel programming feasible in an academic environment. However, root access is required in order to modify a system's kernel. This poses a potential security threat both to other systems on the network and to other users of a single machine. This paper presents a lab design which securely integrates machines with untrusted users acting as root into a secured network, and which securely allows multiple users root access to the same machine.
The Swinburne on-line education project
Authors: Pilgrim C. J. , Creek M. J.
Published: July 2004

Many universities throughout the world are exploring the possibilities of on-line delivery of educational programs. These developments have the potential to significantly change the face of higher education as we know it today. In order to compete in an international market, Swinburne University of Technology has decided on a strategic approach to the development of web-based delivery of courses. This paper will report on all aspects of the Swinburne On-line Education (OLE) project especially the developments within the School of Information Technology which has the responsibility for the delivery of Computer Science programs.
Automated collection of coursework using the Web
Authors: Roantree Mark , Keyes Tia E.
Published: July 2004

Coursework is a necessary part of most subjects in most disciplines. Some subjects require a series of continuous assessments to be taken during the course of the semester, resulting in a large amount of paperwork and administrative overhead. In this paper we describe a mechanism for collecting coursework, providing a means of verifying receipt of coursework, and publishing the results automatically. The aim of the work is to provide a user-friendly interface for students to submit all forms of electronic coursework (textual and binary), and an equally user-friendly interface for tutors to download coursework, and subsequently publish the coursework grade. In this way, neither the student nor the tutor need be expert in computing, and the overhead of processing coursework is greatly diminished.
Strategies for using technology in the teaching of ethics
Authors: Roberts Eric
Published: July 2004

Particularly with the advent of the World Wide Web, the Internet has become an important tool in education, both in computer science and across the broader curriculum. This paper describes several strategies for integrating the use of the Internet into a course on computing ethics. Those strategies include using the Internet as a research tool, as a discussion medium, and as a publication channel. While some of those strategies have proved highly effective, others---particularly using the Internet for discussion---have been much more problematical. This paper outlines the problems that arise in each of these usage paradigms and describes how the course has evolved in an effort to address the shortcomings.
Designing a Java graphics library for CS 1
Authors: Roberts Eric , Picard Antoine
Published: July 2004

In recent years, there has been considerable interest in using Java in introductory computer science courses. The advantages of choosing Java, however, must be balanced against two significant drawbacks: the instability caused by the rapid evolution of the Java toolkits and the complexity of the graphics model for new students. This paper outlines a strategy for teaching Java that eliminates these problems. The first component of that strategy is a set of low-level classes, DBCanvas and XGraphics, which together offer a double-buffered graphics model that is well matched to student intuition. The second component is a set of higher-level classes, principally Collage and Widget, which make it easy to introduce object-oriented techniques at the beginning of CS1. The sources for these classes are available on the Web at the URL http://cse.stanford.edu/java