Several national and international computing and engineering organizations are in the process of developing a new curricular document tentatively titled 'Computing Curricula 2020' (CC2020). This curricular project, based on its predecessor CC2005, intends to reflect the state-of-the-art in computing education and practice as well as the future of the computing educational field for the 2020s. This workshop provides an overview of the CC2005 report and its transition to the CC2020 project. It also provides unique perspectives from three members of the CC2020 task force. The workshop authors and participants will engage in lively discussions on ways to include software engineering as a significant component of the project and extend its influence in global undergraduate computing education for the future. The authors anticipate full audience involvement and participation in formulating this vision.

This poster will describe ongoing work to modify the Computing Ontology to incorporate issues of parallelism and concurrency, motivated by recent developments in computer hardware design.

In 2001, the ACM and the IEEE-CS published Computing Curricula 2001 which contains curriculum recommendations for undergraduate programs in computer science. That report also called for additional discipline-specific volumes for each of computer engineering, information systems, and software engineering. In addition, it called for an Overview Volume to provide a synthesis of the various volumes. The Computing Curricula 2004 Task Force undertook the job of fulfilling the latter charge. The purpose of this session is to present the recently completed work of that Task Force, now known as Computing Curricula 2005 (CC2005), and to generate discussion among, and feedback from SIGCSE members about ongoing and future work.

This paper is an overview of Software Engineering 2004, the Software Engineering volume of the Computing Curricula 2001 project. We briefly describe the contents of the volume, the process used in developing the volume's guidelines, and how we expect the volume to be used in practice.

The Software Engineering Volume is part of the IEEE-CS/ACM Computing Curricula effort that began in the fall of 1998 when a group of dedicated individuals from the IEEE Computer Society and the ACM were appointed by the two societies to begin work on what was then called Computing Curriculum 2001. This Steering Committee came to the conclusion that the area of computing had gone beyond the boundaries of computer science and that one volume would not effectively contain all of the newer areas of computing that had been developed. It was decided to split the Computing Curriculum effort into several volumes: namely, Computer Science, Computer Engineering, Software Engineering, and Information Systems volumes. The main goals of the IEEE-CS/ACM Computing Curricula effort are to provide guidance to academic institutions and accreditation agencies about what should constitute an undergraduate education in one of the aforementioned areas.

Article Share on IEEE-CS/ACM computing curricula: computer engineering & software engineering volumes Authors: John Impagliazzo Hofstra University, Hempstead, NY Hofstra University, Hempstead, NYView Profile , Esther A. Hughes Virginia Commonwealth University, Richmond, VA Virginia Commonwealth University, Richmond, VAView Profile , Richard LeBlanc Georgia Tech, Atlanta, GA Georgia Tech, Atlanta, GAView Profile , Tim Lethbridge University of Ottawa, Ottawa, Ontario, Canada University of Ottawa, Ottawa, Ontario, CanadaView Profile , Andrew McGettrick University of Strathclyde, Glasgow, United Kingdom University of Strathclyde, Glasgow, United KingdomView Profile , Ann E. K. Sobel Miami University, Oxford, OH Miami University, Oxford, OHView Profile , Pradip K. Srimani Clemson University, Clemson, SC Clemson University, Clemson, SCView Profile , Mitchell D. Theys University of Illinois at Chicago, Chicago, IL University of Illinois at Chicago, Chicago, ILView Profile Authors Info & Claims SIGCSE '04: Proceedings of the 35th SIGCSE technical symposium on Computer science educationMarch 2004 Pages 450–452https://doi.org/10.1145/971300.971453Published:01 March 2004Publication History 0citation798DownloadsMetricsTotal Citations0Total Downloads798Last 12 Months4Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access

Though software testing courses are commonly taught as part of software engineering curricula, software testing is still a challenging issue in software engineering education. Students frequently see testing only as something that happens at the end of the development process. Two challenges can be recognized: "how to make the students recognize the relevance of the testing activity?" and "how to motivate the students on using testing ideas in their projects?". In an attempt to explore the impact of introducing testing practices throughout development, during the past Fall semester we modified the project requirements in a course on object-oriented analysis and design offered to the undergraduate students in computer science at Georgia Institute of Technology. Our idea was to require the students to start thinking about testing as early as possible, by including testing-related practices in all phases of the development process. This paper presents the details of the testing approach used in the course and discusses the results we obtained, in terms of the students' attitudes and learning.

The Software Engineering Volume is part of the IEEE-CS/ACM Computing Curriculum effort that began in the Fall of 1998 when individuals from the IEEE Computer Society and the ACM formed a Steering Committee and began work on the Computer Science Volume. This Steering Committee came to the conclusion that the area of computing had gone beyond the boundaries of computer science and that one volume could not effectively cover the newer areas that had been developed. It was decided to split the Computing Curriculum effort into several volumes; to cover Computer Engineering, Software Engineering, and Information Systems. The Steering Committee continued to work on the Computer Science Volume and appointed others to work on the other volumes.

This paper introduces a new programming methodology for building real-time systems that allows the construction of concurrent programs without the explicit creation and synchronization of threads. The approach requires the program to have an acyclic invocation structure. This restriction allows an underlying CycleFree Kernel to implicitly schedule units of concurrency and synchronize access to objects. Deadlock is avoided by the hierarchical access to objects, and programmers are freed from the traditional worries of explicit task creation and synchronization.The paper discusses real world, commercial experiences, both with explicit multi-threaded applications and with CycleFree applications. The potential pitfalls associated with programming concurrent processes are well known to those skilled in the art. The issues of race conditions, reentrancy, and cyclic deadlock can lead to transient program failure. The CycleFree methodology eliminates these sources of transient program failure, leading to more reliable and robust software. Simtrol, an A/V control systems company, used the CycleFree technology in the construction of two real-time control systems called ONGOER and Omega. Programmers with little previous real-time programming experience can easily embrace this methodology. CycleFree™ technology is protected under U.S. patent number: 6,035,321.

No abstract available.

In the fall of 1998, the ACM Education Board and the Educational Activities Board of the IEEE Computer Society appointed representatives to a joint task force to prepare Curriculum 2001, the next installment in a series of reports on the undergraduate Computer Science curriculum that began in 1968 and was then updated in 1978 and 1991. The purpose of this panel is to present an overview of the early work of the task force and to generate discussion in the SIGCSE membership about the directions and plans for the new curriculum.

Traditional undergraduate Computer Science curricula have been increasingly challenged on a host of grounds: undergraduate com- puting education is attracting fewer majors, is not producing graduates who satisfy the needs of either graduate programs or business and industry, and is not effectively responding to the increasing needs for computing education among the larger student population.In the face of such challenges, there has been a recent movement to restructure undergraduate computing curricula.

Past research has concentrated on ordering events in a system where processes communicate through messages. The authors look at issues in ordering events in a distributed system based on shared objects that interact via remote procedure calls (RPCs). They derive clock conditions for ordering operations on an object and provide clock maintenance schemes for time-stamping execution events. An object clock is associated with every shared object for clock exchange among processes. A clock maintenance algorithm is incrementally presented for objects where operations are atomic and an algorithm is described for large-grained objects where operations are nested and non-atomic.>

Discusses the design and the operating system support necessary for providing asynchronous event handling in distributed, passive object-based programming environments, where objects are potentially shared by disparate applications. We discuss the necessity of thread-based as well as object-based event notification and how a variety of hard-to-solve distributed programming issues can be handled by using the approach outlined in the design. The usefulness of the design is considered by using some examples. The implementation strategy and related work in this area are discussed.>

Distributed shared memory consistency protocols suffer from poor performance due their lack of application spe cific knowledge which can be exploited in message passing systems. Explicit synchronization can be used in mem ory coherence activities to realize the benefits of applica tion specific information if the user is allowed to associate data with synchronization operations. In this paper, we present a refinement of synchronization and data sharing patterns and identify attributes that can be used to asso ciate data with suitably modified synchronization primi tives. We present modifications for semaphores, read-write locks, and barriers which can be used to implement a va riety of interaction patterns including mutual exclusion, producers-consumers, readers-writers etc. We claim that the performance of applications programmed using shared memory can be comparable to their message passing imple mentation which use intermediary entities such as mail boxes. On the other hand, programming is easier with our system, since it allows for richer patterns of interaction than when directly using low-level messages.

A description is given of Clouds, an operating system designed to run on a set of general-purpose computers that are connected via a medium-to-high-speed local area network. The structure of Clouds promotes transparency, support for advanced programming paradigms, and integration of resource management, as well as a fair degree of autonomy at each site. The system structuring paradigm chosen for Clouds is an object/thread model. All instances of services, programs, and data in Clouds are encapsulated in objects. The concept of persistent objects does away with the need for file systems, replacing it with a more powerful concept, namely, the object system. The facilities in Clouds include integration of resources by location transparency; support for various types of atomic operations, including conventional transactions; advanced support for achieving fault tolerance; and provisions for dynamic reconfiguration.>

A description is given of the results of a study of methods of achieving fault tolerance in the Clouds system and, in particular, of achieving increased availability of objects. The problems explored in this work, the model of distributed computation in which the problems posed by the research were examined (the Clouds system), the tools that were used to address these problems (the Aeolus programming language), and some related research are briefly described. The authors present a methodology for achieving available services by conversion of resilient single-site implementations into replicated implementations. A mechanism with which they propose to support this methodology, called distributed locking (DL), is presented. A description is also given of a linguistic feature for the specification of the availability properties of an object replicated via DL. The language runtime support features (primitives) required for DL and the operating system support needed for these features are presented.>

A study of the predictive value of a variety of syntax-based problem complexity measures is reported. Experimentation with variants of chunk-oriented measures showed that one should judiciously select measurable software attributes as proper indicators of what one wishes to predict, rather than hoping for a single, all-purpose complexity measure. The authors have shown that it is possible for particular complexity measures or other factors to serve as good predictors of some properties of program but not for others. For example, a good predictor of construction time will not necessarily correlate well with the number of error occurrences. M.H. Halstead's (1977) efforts measure (E) was found to be a better predictor that the two nonchunk measures evaluated, namely, T.J. McCabe's (1976) V(G) and lines of code, but at least one chunk measure predicted better than E in every case.>

There are two basic approachs to the problem of storage reclamation, process- and processor-based, named for the view point used to recognize when a particular piece of storage can be reclaimed. Examples of the processor approach include mark/sweep and copying algorithms and their variants, while reference counting schemes use a process view of the collection. It is argued that the process approach is better suited for distributed computation where links between dynamically allocated objects may cross processor boundaries. In addition, the process approach allows the heap to be more conveniently shared with other processes in those cases when different processes might not have their own virtual address spaces. A new algorithm using the process approach is given. Its space requirement per object is better than that for reference counting. In addition, a restricted form of pointer replacement is supported which allows circular structures so constructed to be properly collected.

A very simple and efficient technique for the introduction of separate compilation facilities into compilers for block-structured languages is presented. Using this technique, programs may be compiled in parts while the compile-time checking advantages of compilation as a whole are retained. These features are simple for a programmer to understand and are easy to implement. Experience has shown this separate compilation mechanism to be a useful tool in the development of large programs in block-structured languages.

Abstract A practical approach to the development of a high‐quality, re‐usable code generator is described in this paper. This code generator produces code for the Prime 64V mode architecture, but the methodology used is generally applicable to the construction of compilers for most architectures. The code generator accepts a tree‐structured intermediate form, linearized and represented as a file of integers. This intermediate form uses high‐level operators, minimizing work by compiler front‐ends that use it and providing a number of advantages in the code generation process. The output of the code generator is assembly language. This tool was found to considerably extend the capabilities of students in a graduate compiler class and has been used in the construction of Pascal and C compilers.

Abstract The results of a case study in which over 100,000 Pascal program executions were monitored for run‐time errors are reported. A large number of run‐time errors in a wide variety of categories were observed. The data reported provided insight into the use and misuse of the features of Pascal by a large population of programmers. Some implications of these statistics on compiler implementation and programming language design are discussed. The number and variety of errors detected suggests that run‐time checking mechanisms are more important and useful than is generally recognized, judging by the incompleteness of such mechanisms in many compilers.

This paper considers the role of run-time diagnostic checking in enforcing the rules of the Pascal programming language. Run-time diagnostic checks must be both complete (covering all language requirements) and efficient. Further, such checks should be implemented so that the cost of enforcing the correct use of a given construct is borne by users of that construct. This paper descxibes simple and efficient mechanisms currently in use with a diagnostic Pascal compiler that monitor the run-time behavior of such sensitive Pascal constructs as pointers, variant records, reference (i.e., var) parameters, and with statements. The use of these mechanisms with related constructs in other languages is considered. Language modifications that simplify run-time checking ate also noted.