bluuebunny/crossref_metadata_2025 huggingface dataset:
Using locality of reference to improve performance of peer-to-peer applications
Authors: Barbosa Marcelo Werneck , Costa Melissa Morgado , Almeida Jussara M. , Almeida Virgílio A. F.
Published: July 2004

Peer-to-peer, or simply P2P, systems have recently emerged as a popular paradigm for building distributed applications. One key aspect of the P2P system design is the mechanism used for content location. A number of different approaches are currently in use. In particular, the location algorithm used in Gnutella, a popular and extensively analyzed P2P file sharing application, is based on flooding of messages in the network, which results in significant processing overhead on the participant nodes and thus, poor performance.In this paper, we provide an extensive performance evaluation of alternative algorithms for content location and retrieval in P2P systems, in particular, the Freenet and Gnutella systems. We compare the original Freenet and Gnutella algorithms, a previously proposed interest-based algorithm and two new algorithms which also explore locality of interest among peers to efficiently allow content location. Unlike previous proposals, the new algorithms organize the peers into communities that share interests. Two peers are said to have common interest if they share some of the locally stored files.In order to evaluate the performance of these algorithms, we use a previously developed Freenet simulator and build a new Gnutella simulator, which includes several realistic system characteristics. We show that the new community-based algorithms improve the original Gnutella content location latency (and thus the system QoS) and system load by up to 31% and 30%, respectively. Our algorithms also reduce the average Freenet request and response path lengths by up to 39% and 31%, respectively. Furthermore, we show that, compared to the previously proposed interest-based algorithm, our new algorithms improve query latency by up to 27% without a significant increase in the load.
Collecting whole-system reference traces of multiprogrammed and multithreaded workloads
Authors: Kaplan Scott F.
Published: July 2004

The simulated evaluation of memory management policies relies on
reference traces
--logs of memory operations performed by running processes. No existing approach to reference trace collection is applicable to a complete system, including the kernel and all processes. Specifically, none gather sufficient information for simulating the virtual memory management, the filesystem cache management, and the scheduling of a multiprogrammed, multithreaded workload. Existing trace collectors are also difficult to maintain and to port, making them partially or wholly unusable on many modern systems.We present
Laplace
, a trace collector that can log every memory reference that a system performs. Laplace is implemented through modifications to a simulated processor and an operating system kernel. Because it collects references at the simulated CPU layer, Laplace produces traces that are complete and minimally distorted. Its modified kernel also logs selected events that a post-processor uses to associate every virtual memory and filesystem reference with its thread. It also uses this information to reconcile all uses of shared memory, which is a task that is more complex than previously believed. Laplace is capable of tracing a workload without modifications to any source, library, or executable file. Finally, Laplace is relatively easy to maintain and port to different architectures and kernels.
Software performance engineering of component-based systems
Authors: Bertolino Antonia , Mirandola Raffaela
Published: July 2004

We propose an automated compositional approach for component-based performance engineering, called the CB-SPE. It adapts to a CB framework the concepts and steps of the well-known SPE technology, and uses for input modeling the standard RT-UML PA profile. The approach is two-layered: it is first applied by the component developer to achieve a parametric evaluation of the components in isolation; then by the system assembler, to predict the performance of the components assembly on the actual platform. We also present the CB-SPE tool architecture and its current status.
Visualization of Java workloads using ternary diagrams
Authors: Dujmović Jozo , Herder Carl
Published: July 2004

In this paper we investigate the use of ternary diagrams for visualization of Java workloads, and show how to use this technique for an analysis of JVM98 SPEC benchmarks. Ternary diagrams present workloads as points in plane with respect to three characterization parameters. They can be combined with other visualization techniques based on dendrograms, histograms, pie charts, and Kiviat graphs. Java workloads are characterized using dynamic frequencies of bytecodes (or timed bytecodes). Related bytecodes are grouped, and their frequencies aggregated, to reduce dimensionality. We propose four ways for grouping Java bytecodes and use them to analyze properties of Java workloads. Our methodology is generally applicable in all cases where workload characterization is based on compiler-generated intermediate or machine code.
Operating system scenarios as Use Case Maps
Authors: Billard Edward A.
Published: July 2004

This paper summarizes the analysis, design, implementation, and performance analysis of an object-oriented operating system. The analysis applies Use Case Maps (UCMs) to provide a high-level abstraction of the behavior scenarios for state transition, character output, network access, and disk access. The UCM for state transitions is converted into a queueing network for simulation study of I/O-bound versus CPU-bound systems. An overview of the later stages emphasizes UML for architecture and detailed collaboration, as well as Java examples. The performance of the disk sub-system is analyzed by instrumenting the Java code, and the results show that design choices can affect the throughput.
The Second International Workshop on Detection of Software Clones
Authors: Walenstein Andrew , Lakhotia Arun , Koschke Rainer
Published: July 2004

This report is intended to summarize the proceedings of the Second International Workshop on Detection of Software Clones (IWDSC'2003). The aim of the workshop was to bring together researchers within the field of clone detection to critically assess the current state of research, and to establish new directions and partnerships for research. There were at least 30 people in attendance. Five position papers were presented and discussed. In addition, an index card-based brainstorming technique was used to focus discussion on assessing the current state of clone analysis and detection. A report and analysis of the results of this brainstorming session is the main content of this report. We recommend another international workshop on clones and clone detection be set to be held alongside another conference sometime in 2004.
Assessing software structure by entropy and information density
Authors: Cardoso Ana Isabel , Crespo Rui Gustavo , Kokol Peter
Published: July 2004

In this paper we show how the long range correlation and the local entropy measures in the software program can give indication about its structure. First we define a long range correlation and local entropy introducing a list of examples of use of those measures across different fields. We then present a method to calculate the long range correlation in the Software Engineering and we use that method in a Case Study. Finally we conclude that the use of those two metrics, borrowed from the complex systems theory, are potential and easier for measuring the object program structure.
Approximations, anomalies and "the proof of correctness wars"
Authors: Fass Leona F.
Published: July 2004

We discuss approaches to establishing "correctness" and describe the usefulness of logic-based model checkers for producing
better
practical system designs. While we could develop techniques for "constructing correctness" in our theoretical behavioral-modeling research, when applied to Real World processes such as software development only
approximate
correctness might be established and anomalous behaviors subsequently found. This we view as a positive outcome since resultant adaptation, or flaw detection and correction, may lead to improved development and designs. We find researchers employing model checking as a formal methods tool to develop
empirical
techniques have reached similar conclusions. Thus we cite some applications of model checking to generate tests and detect defects in such Real World processes as aviation system development, fault-detection systems, and security.
A page-transition framework for image-oriented Web programming
Authors: Shimomura Takao
Published: July 2004

To develop Web applications, various integrated development environments have been used. In addition, several frameworks for efficiently developing those applications have been proposed. This paper presents the image-oriented page-transition framework that models a Web application as a set of transitions of Web pages, and using visual components, makes it easier to write processes executed when a Web page transfers to another Web page. This page-transition framework has the following novel features: (1) The developers of Web applications do not need to write any processes for receiving and analyzing submitted form data. (2) The data submitted by page transfers are stored in the appropriate variables that are automatically generated. Using these automatically generated variables, the developers can write necessary actions for each Web page from which control transfers. (3) The developers can deal with tables used inside the programs as visual components, and can use these components to design dynamic Web pages.
The programmer life-cycle
Authors: Ovans Russell
Published: July 2004

The traditional analysis of programmer productivity ignores the reality that work rates of programmers are variable over time. Not unlike the software systems they construct, programmers follow a predictable life-cycle. However, the programmer life-cycle is not comprised of activities but rather by phases that directly affect and predict productivity. The sequence of phases is: euphoric, productive, irreplaceable, resentful, bored, and unproductive. Overall productivity is characterized by an initial six month period of intense interest, at which time productivity rates are often an order of magnitude higher than the oft-quoted 500 LOC/month average. After a short period of volatility, the programmer then enters a prolonged phase of steadily dwindling interest, resulting in productivity rates that mimic the average. Each time a programmer switches employers or begins a significantly new project, the life-cycle starts anew.
Second International Workshop on From SofTware Requirements to Architectures (STRAW'03)
Authors: Berry Daniel M. , Kazman Rick , Wieringa Roel
Published: July 2004

The Second International Workshop on From SofTware Requirements to Architectures (STRAW'03) was held in Portland, Oregon, USA on 9 May 2003 just after the Twenty- Fifth International Conference on Software Engineering (ICSE'03). This brief paper outlines the motivation, goals, and organization of the workshop, summarizes the presen- tations, and, along the way, gathers some lessons learned about running a workshop.
Knowledge based reasoning for software architectural design strategies
Authors: Ramachandran Muthu , Mangano Domenic
Published: July 2004

It is well known that the backbone of any system is the architecture which holds the whole system together to manage the complexity and requirements changes. The past twenty years or more of research into software and IT systems design has resulted in exponential growth of architectural design strategies. Therefore it has also resulted in confusion for many software engineers who may not be experts in software design to understand and choose a suitable architectural solution to their problem. We have tackled this issue by providing a classification framework and knowledge based reasoning for software designers to choose the appropriate strategies for their problem. This paper illustrates a classification schemes for architectural design strategies and a tool support for knowledge based reasoning for choosing a design solution.
Compiler course vs. translators course
Authors: Calingaert Peter
Published: July 2004

To teach translators by means of an elementary compiler design course and portions of several other courses does not serve students as well as a course on all translators, which can be followed by a more specialized course on compiler design. The reasons are reviewed and a flexible course on translators is described. The benefits of the resulting arrangement are set rortn.
Systems analysis and design in a computer science curriculum
Authors: Spence J. Wayne , Grout Jarrell C.
Published: July 2004

Some of the recent dialogue in computing publications and conferences has dealt with a topical area referred to as "software engineering" or "systems analysis." This paper provides a description of a course in this area and a discussion sufficiently adequate for the implementation of the course in an undergraduate computer science curriculum. The course is recommended for inclusion in the ACM curriculum guide under the special topic, "Software Engineering: Large Systems Design."
Team dynamics and the undergraduate curriculum
Authors: Hansen John C. , Hansen Elizabeth A. , Derus Kenneth H.
Published: July 2004

The work habits of computer science students are rarely good. Most students adopt undesirably hermetic attitudes toward problem solving, despite the fact that large-scale programming problems demand cooperative efforts for their effective solution.This is not surprising. Students learn to write programs by working alone, and are rewarded for creating programs which are somehow innovative. Much of the work produced in this sort of fashionably competitive setting is poorly communicable. Students develop idiosyncratic styles of working out-and writing down-their results, and have difficulty understanding and appreciating each other's accomplishments. Indeed, it could be said that student programs are "original" largely to the extent that they are unintelligible to other students of ostensibly similar background.This paper outlines some ways in which the curriculum of undergraduate computer science courses can be designed to promote team-oriented attitudes toward problem solving. Each of the examples discussed has been used by one or more of the authors in undergraduate classes.
Yet another survey of graduate programs in computer science
Authors: Schneider G. Michael
Published: July 2004

This paper performs a quantitative ranking of the graduate programs in computer science at major universities in the United States and Canada. The rankings are based on the number of journal articles which have appeared in 12 major journals over the past two years. The paper also includes a ranking of major corporate research centers and foreign universities. The paper concludes with suggestions about how, in the future, such surveys should be conducted under the auspices of the professional organizations of computer science, e.g., ACM, SIGCSE.
Preliminary proposal for a National Educational Computing Consortium
Authors: Bork Alfred , Kniefel David , Duncan Karen , Holznagel Donald
Published: July 2004

"This proposal suggests the initiation and activities of a new organization for the development of the computer in learning, an organization which will initially be formed from a number of existing organizations in this area. The proposed organization will be called the National Educational Computing Consortium.
A course structure
Authors: Thurber Kenneth J.
Published: July 2004

The purpose of this paper is to describe a senior/graduate level introductory computer communication architectures course from a distributed system architecture level. The course will deal with switches, paths, and their system implications. Functional topology issues of distributed and network systems are discussed. The implementation of their data transfer mechanisms via paths and switches is considered from the viewpoint of their protocol and construction tradeoffs.This course is based around seminar courses taught at the University of Minnesota in the Computer Science Department, a book to be published in June 1979, by D. C. Heath, and a tutorial developed for the IEEE Computer Society to be given at the first Annual International Distributed Processing Conference.
Curriculum recommendations and guidelines for the community and junior college career program in computer programming
Authors: Little Joyce Currie , Austing Richard H. , Seeds Harice , Maniotes John , Engel Gerald L.
Published: July 2004

Curriculum recommendations are given for a two year Associate Degree program to prepare computer programmers for jobs. The program is specifically directed toward the education of the computer programmer who works in conjunction with a systems analyst in the programming environment usually found in a medium to large job shop. Graduates should be qualified to do entry-level applications programming to support the general, administrative, and organizational information processing functions of industry, commerce, business, and government service.The history of and need for education in the computer field at the two year college level are discussed. Specific objectives and subject matter for the curriculum are given. Recommendations for facilities and staff resources needed to support such a program are made. Suggestions for implementation and for adaptation for continued relevance are given.
The Gordian knot program
Authors: Korfhage Robert R.
Published: July 2004

A simple device is presented for impressing students with the perils of unbridled "go to" statements. Whether or not one believes in go-to-less programming, it is clear to experienced programmers that unrestrained use of a go to statement leads to programs that are difficult to understand. This is much less clear to students in a beginning course, who see only very short programs. To impress these students that there is a problem, I frequently ask them to rewrite a "Gordian knot" program - one which is more than 50% go to statements - in the shortest possible form. A twenty-line program of this character is easy to construct, and gets the point across. Here is an example, which may be solved either under the assumption that only the very last value computed is needed, or that the final values of all variables (x, y, and z) are needed.
An interactive pattern recognition laboratory (IPRL)
Authors: Christodoulakis Starvos
Published: July 2004

This paper describes an interactive pattern recognition laboratory. The laboratory was designed for both research and teaching. For the researcher, it provides standard pattern recognition functions, a hierarchically organized pattern recognition data base, and a multidimensional graphic display capability. For the student it provides, in addition to the above capabilities, a vehicle for developing new pattern recognition algorithms. In addition to not having to develop support software, the student may compare the performance of his algorithms in the same environment as the existing ones.
A basic monitor system for implementation in operating systems and computer architecture courses
Authors: Stoddard Spotswood D. , Coon Lawrence A.
Published: July 2004

A small operating system suitable for implementation by intermediate level students as a laboratory assignment is described. Although purposely reduced to essentials, the system will actually execute a stream of user jobs. The system is structured in such a way that extensions in various directions are straightforward once the basic system is implemented.
The results of an informal study to evaluate the effectiveness of teaching structured programming
Authors: Shapiro Henry D.
Published: July 2004

An informal experiment to evaluate the effectiveness of teaching structured programming from the beginning of a student's career as a computer science student was conducted during the summer session of The University of New Mexico. Performed at the last minute, and clearly unscientific in both design and implementation, the results suggest that too great an emphasis on programming without GOTOs leads to poor programming style and incorrect implementation of straightforward algorithms.
A computer science curriculum at IBM Boulder
Authors: Abshire Gary M.
Published: July 2004

In 1976 a college level, computer science curriculum consisting of 14 courses was offered at IBM Boulder. The courses ranged from introductory courses in information processing to an advanced course in integrated computer systems. This article describes that curriculum in detail.
A service course in computing science presented from a historical point of view
Authors: Smillie K. W.
Published: July 2004

A description is given of an introductory service course in computing science intended for students in the liberal arts and humanities in which the subject is presented from a historical point of view beginning with the civilizations of ancient Egypt and Babylon and continuing until the most recent developments in programming languages and microcomputers and their applications.
A survey of interactive computing support in American colleges and universities
Authors: Wright William E. , McGlinn Robert J. , Harris J. Archer
Published: July 2004

This paper reports on a survey of 4-year colleges and universities in the United States and Canada concerning their level of support for interactive computing. A brief questionnaire was sent to almost all such institutions offering a bachelor's, master's, or doctoral degree in computer science. It was addressed to the chairman of the Computer Science department. The survey attained an exceptional response rate of 82%, with 187 responses out of 228 questionnaires sent. The primary finding of the survey was that, on the average, approximately two-thirds of student jobs are submitted from interactive terminals and one-third are submitted on punch cards. The level of interactive computing support was found to be largely independent of university enrollment or number of computer science majors, and modestly dependent on the stature of the institution. An unrelated finding was that, on the average, the primary computing facilities are open for student use 19 hours per day.
A practical undergraduate introduction to software engineering
Authors: Foreman John
Published: July 2004

Much has been written about proper software engineering methods and how to teach these techniques to students. Several authorities have analyzed our present techniques as needing significant improvement [1]. This paper discusses a practically oriented introduction to software engineering aimed at introducing students to sound development habits and life-cycle thinking early in their careers.
An emhanced pseudo-code notation
Authors: Weiss David L.
Published: July 2004

This paper describes a tool for improving programming. As a final step before coding, Inputs and outputs can be appended to each line of pseudo code. This procedure guarantees completeness and helps with correctness.
Evolution of a program in computing for a Latin American graduate college
Authors: Villaseñor Yolanda F.
Published: July 2004

This paper describes the evolution in the design of an academic program in computing at the graduate level in a developing country. The particular norming aspects of the program's environment are discussed. This program is sui generis due to the requirements of the particular institution where it exists. Some of the factors that affect academic programs in computing in a developing country are briefly commented.
Students aiding students
Authors: Higginbotham T. F.
Published: July 2004

The results of the use of student proctors for debugging aid in programming courses is reported. Effectiveness of the program is discussed with respect to: (1) supervision, (2) faculty response, (3) student participation, (4) student use, and (5) mistakes I made.
Teaching Cobol
Authors: Citron Judith
Published: July 2004

COBOL courses have traditionally relied heavily on lectures. Research indicates, however, that lectures have little effect on problem solving ability which is the most taxing aspect of writing programs.This article describes an experimental course design for teaching COBOL, that stresses problem solving by more active involvement than lectures. Independent reading, followed by a consolidating lecture, then group tutorial work followed by program writing are integrated in a spiral fashion, each block building on the previous one, gradually combining syntax and semantics.The monitoring of the course showed that students found that tutorials prepared them well for coursework (writing complete COBOL programs) which was considered the most beneficial activity of the course. Tutorials were seen to expose the students to alternative solutions which is an essential ingredient of problem solving, although students could not always see the direct relevance of the tutorials to COBOL knowledge. Lectures it was felt could not be discarded altogether as they helped clarify the reading. The gradual build-up of knowledge integrated with practice was felt to be helpful.In summary, further development of courses along these lines was considered worthwhile to achieve the broader objectives of improved problem solving ability, team work, and a more motivating learning environment for the learning of COBOL, which lectures cannot achieve.
Enhancing Cobol program structure
Authors: Richards R. M.
Published: July 2004

COBOL is sometimes criticized for its lack of structurability. This is due primarily to the common but outdated use of paragraphs to achieve structure in COBOL programming.In fact. COBOL was designed to be highly structurable. The language itself is based on a hierarachical structure consisting of DIVISIONS, SECTIONS, paragraphs, sentences, and statements. The task is to train COBOL programmers to take maximum advantage of the structures built into the language.One way to do this is to use SECTION structure in the procedure division rather than paragraph structure. SECTION structure has several distinct advantages over paragraph structures and allows for maximum utilization of the structured approach to COBOL programming.
Thoughts on university computer curricula
Authors: Stoob John C.
Published: July 2004

The forms of computer programs that might be found at a university are discussed. The idea is established that computer curricula at a university should reflect the extent and depth of computer use in society. That extent and depth is great and pervades most every area of life. Similarly, computer curricula, programs and courses at universities should exist and florish in all disciplines and not be restricted to residency in just one or two in the names of efficiency and/or required special expertise.
A formal method for determining if a grammar is connected and grounded
Authors: Burris David S.
Published: July 2004

This paper introduces a formal method for determining if the production rules in a regular or context free grammar are "connected" (can appear in a sentential form) and "grounded" (can be driven to a string of terminal symbols). I have used it on several occasions in courses on programming language design or language translator implementation to verify that proposed student grammars were reduced (connected and grounded). The technique is also useful for reviewing matrix algebra and the theory of relations with students. The student must know or be introduced to Warshall's algorithm for generating the transitive closure of a relation [1--4].
Teaching structured assembler programming
Authors: Tran Con , Robillard Pierre N.
Published: July 2004

The concepts of structured programming learned in higher level languages are usually not sufficiently emphasized in teaching assembly languages. In this study, students have used a tool called SCHEMACODE to design in assembly language by means of a higher level schematic pseudocode. The tool automatically generates the assembly code. Data from an experiment involving two groups of students are presented. One group uses a conventional approach based on flow charts and the other group uses the structured approach based on schematic pseudocode. Programs are compared on the basis of memory space and memory cycles. Results show that structured programming in assembly language is as efficient as conventional programming. The programs are much more readable and are therefore easier to maintain.
A curriculum model for a graduate degree program in systems analysis
Authors: Byrkett Donald L. , Uckan Yuksel
Published: July 2004

A much needed master's level graduate degree program in systems analysis has been designed and proposed for implementation at Miami University. There are many graduate curricula that emphasize information systems, computer science, or operations research; but our proposal is unique in its attempt to combine these varied, yet related, disciplines. This paper describes the details of the proposed curriculum which largely conforms to the major curriculum recommendations. The proposal is sufficienctly general to be adopted as a model by programs of similar mix and emphasis.
Visual demonstration of program execution
Authors: Kline Russell B. , Hamor Gary D. , Krause Kenneth L. , Druffel Larry E.
Published: July 2004

This paper describes a system which provides a visual demonstration of the structure and flow of an ALGOL program. The program is displayed on a CRT and executed interpretively, highlighting each statement prior to execution and showing the result of the statement after execution. The primary use of the system is to demonstrate program operation in a classroom environment. It has also been used as an automatic benchchecking aid.
A professional master's degree program in computer science
Authors: Magel Kenneth , Mills Everald E.
Published: July 2004

A graduate program leading to the Master of Computer Science degree is described. It is a terminal degree intended to provide advanced training for computer science professionals, particularly those whose original training was in areas other than computer science. The paper starts by comparing this type of program to master's programs at other schools. The potential audience for a program of this type is described. The actual program at Wichita State University is explained and four sample student schedules are given.
A report on the use of multimedia courses in computer science education
Authors: Hansen William A.
Published: July 2004

This report describes the author's experience using commercially-available, video-based, multimedia training courses to teach undergraduate computer science courses. The multimedia courses were used as the primary teaching vehicle in an entry-level COBOL course and a junior-level systems analysis course. They were also used to supplement the discussion of direct access file design in a data structures course.
The bachelor's and master's computer science graduate
Authors: Kerr Douglas S. , Kalmey Donald L.
Published: July 2004

This paper deals with a survey of the bachelor's and master's degree graduates from the Department of Computer and Information Science at The Ohio State University conducted during 1975. The purpose of the survey was (1) to determine what positions the graduates held, (2) to determine how effective the curricula had been, (3) to obtain an evaluation of these curricula, (4) to determine possible improvements, and (5) to see if there were distinctions between bachelor's and master's degree recipients. Some of the results about the bachelor's degree graduates have already been reported in Kalmey [74]. As of August 1974, the Department had conferred about 600 Bachelors, 280 Masters and 17 Ph.D. degrees.
Teaching data management using an educational data base management system
Authors: Lochovsky F. H. , Tsichritzis D. C.
Published: July 2004

Data base management systems are gaining rapid and widespread use by organizations attempting to improve their data management facilities. Several commercial DBMS's are available and educators are increasingly introducing students to concepts and techniques of data management. An important part of grasping data management concepts is to provide hands-on experience in using a data base management system. The Educational Data Base System is a tool designed to provide this hands-on experience in a teaching environment. It has been used successfully in this capacity for several years and has been distributed to over twenty different organizations in seven countries. This paper briefly describes the system and outlines how it is used at the University of Toronto to augment classroom teaching of data management concepts.
Cooperative education
Authors: Alexander Roberta R. , Hatfield Frank J.
Published: July 2004

What is involved?--Any successful cooperative education program must start with sound planning. The ingredients for this planning activity must involve a knowledge of the many factors involved in cooperative education such as history, objectives, scheduling, staffing, administration and cost factors.The primary objective of co-op at most schools is education. Theories and principles learned in classrooms are reinforced and given concrete application while on a co-op assignment. The planning of cooperative education ought to be established on a network of premises about the academic institution, student profile, economic needs, student needs, and both employer and student willingness to be involved in cooperative education, Staff qualifications are very important. The Director/Coordinator is an educator, placement counselor, salesman, administrator, arbitrator and referral agent. Considerations such as awarding academic credit, scheduling of co-op assignments, prerequisites and other administrative details must be planned for. Cooperative education in computer science can be an extremely effective learning tool but it is essential for an institution to know what is involved.
Curricula in computer science and engineering
Authors: Rine David C.
Published: July 2004

This paper offers a brief review and survey which includes the following curricula: (1) A Curriculum in Computer Science and Engineering, The IEEE Computer Society (1977); (2) Curriculum Recommendations for the Undergraduate Program in Computer Science, The ACM (1977); (3) Curriculum Recommendations and Guidelines for the Community and Junior College Career Program in Computer Programming, The ACM (1977); (4) Guidelines for IEEE EE and Ad Hoc Visitors on ECPD Accreditation Teams, Computer Science and Engineering Programs, IEEE/ECPD (1977); (5) The Computer in the Engineering Curriculum- CoED/ASEE(1977); (6) Special Interest Group on Software Engineering Education, SIGSOFT/ACM. A brief outline of some of the future requirements in the following areas is also given: (1) Continuing Education; (2) Computer-oriented business and engineering education; (3) maintaining up-to-date facilities.
A sequence of computing courses for liberal arts colleges
Authors: Ahlgren D. , Sapega A. , Warner H.
Published: July 2004

Techniques such as structured programming and the use of a restricted set of control structures have transformed computer programming into a well-understood discipline. A sequence of courses in computing based on these principles has been developed and is described in this paper. The teaching of general principles of computing is in keeping with the liberal arts philosophy which stresses general ideas rather than specific applications.
Opinions on computer science courses for precollege level teachers
Authors: Moursund David
Published: July 2004

There is growing awareness that calculators could/should play an integral role in elementary school and secondary school education. But most current precollege level teachers have received little training about calculators and computers. Most teacher training institutions have given relatively little thought to these issues. This paper lists several possible courses that might be offered to elementary school or secondary school teachers. A questionnaire about these courses was mailed to 363 people interested in the field of computers in education. This paper analyzes and discusses the results of the 188 questionnaires that were returned.
The cost-effectiveness of team debugging in teaching cobol programming
Authors: Lemos Ronald S.
Published: July 2004

A team-debugging approach to teaching introductory COBOL programming is described. Team debugging activities consist of the formation of different three-person teams for each assigned program to read and critique team members' program listings. These activities require no additional resources or drastic changes in teaching style.The effectiveness of this approach was empirically assessed with a sample of 215 undergraduate Business Administration students. An experimental group participated in the team debugging activities while a control group did not. COBOL proficiency was measured by a final examination testing (1) knowledge of language rules, (2) the ability to read a program listing, and (3) the ability to write a program, Analysis of multiple covariance was used to statistically adjust test scores for age and conditional reasoning ability. The experimental group achieved higher mean scores for all three variables. For the program writing variable, the difference was statistically significant (F = 9.50, p < .05).The findings provide empirical support for incorporating team debugging activities into the programming learning process to more effectively develop student proficiency in writing COBOL programs.
An intermediate course on computer systems
Authors: Winner Robert I.
Published: July 2004

This is a report describing an undergraduate junior level and introductory graduate course on computer systems and some of our experiences in teaching it. The course has been taught since 1971 at Georgia Institute of Technology to graduates and undergraduates as well as at Appalachian State University to undergraduates only. It provides a link between programming courses and systems implementation courses.
An effectiveness index for use in university computing center management
Authors: Varanelli Andrew
Published: July 2004

A technique for deriving an effectiveness index for use in managing university computing centers is described. The procedure was tested at ten university computing centers. The focus of this testing was theoretical development. The result of the effectiveness measurement is presented and discussed. The study validated the use of the procedure for evaluating computer center performance within the organizational limits discussed in the paper.
A fundamental computer science course that unifies theory and practice
Authors: Flon Lawrence , Hilfinger Paul N. , Shaw Mary , Wulf Wm. A.
Published: July 2004

If computer programming is to become an "engineering discipline," computer science students must acquire the tools for rigorous analysis and evaluation of programs. An early course in the undergraduate curriculum must introduce the fundamental principles of the discipline, just as freshman calculus teaches the basic analysis skills for most engineering disciplines. The course described in this paper teaches mathematical principles and practical programming applications in a unified form. It has been successfully taught to sophomores for four years.
Reconciling environment integration and component independence
Authors: Sullivan Kevin , Notkin David
Published: July 2004

We present an approach that eases the design and evolution of integrated environments by increasing independence among components. Our approach combines mediators, which localize relationships, and a general event mechanism, which increases the independence of components from relationships in which they participate. To clarify our notion of independence and its relationship to evolution, we analyze four designs for a simple environment. The first three show how common approaches compromise independence in various ways. The fourth design demonstrates how our approach overcomes these problems. Our event mechanism is specially designed to support integration and evolution. We discuss detailed aspects of mediators and events by presenting three environments we have built. Our approach has also given us significant insights into other related systems.
Consistency management in a project management assistant
Authors: Qian Xiaolei , Jullig Richard , Daum Marilyn
Published: July 2004

Object management systems have been identified as the core of object-oriented software development environments. One of the most important objectives of object management systems is to maintain consistency between the vast amount of interrelated objects, which is generated, accessed, and manipulated throughout the software life cycle. Consistency management in such systems is beyond the reach of conventional database technology due to the complex structure and the incompleteness of data, the dynamic nature of constraints, and the need to tolerate various levels of inconsistency. We investigate the design issues for consistency management in the context of a Project Management Assistant. Our consistency manager organizes constraints into a hierarchy of consistency, and associates a spectrum of management techniques with classes of constraints. The various levels of consistency are achieved by enabling or disabling classes of constraints, and propagating constraints cross the class boundary. The constraint manager is capable of compiling constraint specifications into triggers attached to objects in the object base. The architecture is open to new constraints and new management techniques.
Configuration management by consensus: an application of law-governed systems
Authors: Minsky Naftaly H. , Rozenshtein David
Published: July 2004

It is self-evident that if one wants to model and control the cooperative process of software development, one must provide for cooperative decision making. In particular, one should be able to base the decision on whether and how to carry out a given operation on the consensus of several, possibly independent, agents. It is important to emphasize that this is not just a matter of computing the conjunction of some set of conditions. One must also provide a mechanism for establishing any desired consensus structure, which would specify who is allowed to state which kinds of concerns regarding this operation, and what the relationship among these concerns should be.

In this paper we propose a general framework for such decision making by consensus, which is based on the concept of law-governed software development. As a concrete application domain in which to illustrate this framework, we consider here the issue of configuration binding.
Coping with changes in an object management system based on attribute grammars
Authors: Tan Lichao , Shinoda Yoichi , Katayama Takuya
Published: July 2004

In this paper, we discuss methods of dealing with change in an object management system OS/O, which is a prototype of an attribute grammar based object management model, called Object-Oriented Attribute Grammars(OOAG)[SK 9Oa]. OOAG is a hybrid model that combines features of functional and object-oriented paradigms. Various aspects of software object databases can be described using its capabilities. Software objects in OOAG are managed as autonomous, hierarchical trees containing attributes. The OOAG is also capable of describing software processes as hierarchies of software objects, with data driven process enaction mechanism. Many aspects of changes to such a tree, including the evolution of the tree type definition, or the dynamic transformation of its internal structure can be dealt with easily by the benefits of a combined attribute grammars based and object oriented paradigm. We also introduce a mechanism that helps to provide an efficient way for manipulating changed objects. The mechanism is characterized by
meta-objects
that are used to control the evaluation of the changes. Meta-objects prove to be a suitable mechanism for handling change management tasks in evolving object environments.
An environment for documenting software features
Authors: Frederick Hart C. , Shilling John J.
Published: July 2004

The software engineering environment described in this paper directly addresses the problems of modifying software by explicitly linking software designs to implementations - localizing and partitioning the portions of the implementation corresponding to distinct features and thus facilitating understanding. The operations of feature extraction and generic feature instantiation implemented in this environment provide mechanisms for partially automating the configuration of software. Software documentation based on the notion of features not only records information on program function and structure but information on how maintenance is to be performed. Furthermore, a design environment supporting features and feature contexts promotes feature-oriented design which means designing for reuse and maintainability.
A program integration algorithm that accommodates semantics-preserving transformations
Authors: Yang Wuu , Horwitz Susan , Reps Thomas
Published: July 2004

Given a program
Base
and two variants,
A
and
B
, each created by modifying separate copies of
Base
, the goal of program integration is to determine whether the modifications interfere, and if they do not, to create an integrated program that includes both sets of changes as well as the portions of
Base
preserved in both variants. Text-based integration techniques, such as the one used by the UNIX
diff3
utility, are obviously unsatisfactory because one has no guarantees about how the execution behavior of the integrated program relates to the behaviors of
Base
,
A
, and
B
. The first program-integration algorithm to provide such guarantees was developed by Horwitz, Prins, and Reps. However, a limitation of that algorithm is that it incorporates no notion of semantics-preserving transformations. This limitation causes the algorithm to be overly conservative in its definition of interference. For example, if one variant changes the
way
a computation is performed (without changing the values computed) while the other variant adds code that uses the result of the computation, the algorithm would classify those changes as interfering. This paper describes a new integration algorithm that is able to accommodate semantics-preserving transformations.
Software process enactment in Oikos
Authors: Ambriola V. , Ciancarini P. , Montangero C.
Published: July 2004

Despite much research work in progress to model the different facets of software process enactment from different approaches, there are no models yet generally recognized as adequate, and there is need for more experimentation. We describe the Oikos environment and its coordination language ESP: they provide an infrastructure in which experiments may be performed and evaluated.

Oikos predefines a number of services offering basic facilities, like access to data bases, workspaces, user interfaces etc.. Services are customizable, in a declarative way that matches naturally the way ESP defines and controls the software process. ESP allows to define services, to structure them in a dynamic hierarchy, and to coordinate them according to the blackboard paradigm. The concepts of environment and of software process and their interplay are naturally characterized in Oikos, in terms of sets of services and of the hierarchy.

In the paper, an example taken from a real project (the specification of a small language and the implementation of its compiler) shows how Oikos and ESP are effective for software process enactment.

As it is, ESP embeds Prolog as its sequential component, and combines it smoothly to the blackboard approach to deal with concurrency and distribution. Anyway, most of the concepts used to model and enact software processes are largely independent of logic programming.