bluuebunny/crossref_metadata_2025 huggingface dataset:
3-D visualisation of design patterns and Java programs in computer science education
Authors: Callaghan Michael , Hirschmüller Heiko
Published: July 2004

Object technology is the dominant software engineering paradigm in most undergraduate computer science courses. Two important topics in this area are design patterns and Java programming, and indeed these are increasingly taught side by side. This paper describes a novel form of visualisation that makes use of a combination of virtual reality and hypertext to represent the structure and behaviour of object-oriented design patterns and simple Java programs, with the overall aim of providing tools to enhance learning and understanding of these topics.For patterns, the solution part of a pattern, which consists of a software fragment of interacting objects, is visualised in an animated 3-dimensional virtual environment. The virtual reality view is embedded in a rich inter-linked hyper-textual description.For Java programs, the source code is first transformed into the same simple software description language (SVL, Software Visualisation Language) used for patterns. Also included is a simple textual specification of a run-time scenario defining the creation of objects and their typical interaction, together with explanatory "comments". As with design patterns, the structure and run-time behaviour of the Java program can then be visualised in three dimensions with synchronised hyper-textual commentary.
The “Virtual University”
Authors: Carswell Linda
Published: July 2004

Universities make the assumption that providing distance education is a simple process of translating from one medium to the next: the current popular medium being the Internet. However, the danger in this approach is two fold. First, if the components of distance education are ill understood then an inappropriate pedagogy and strategy may result. Second, a lack of understanding of the properties of the Internet as a medium may cause unrealistic and unrealisable expectations. Thus the inappropriate strategy is matched to an unreliable medium expectation and the distance education programme is unlikely to provide the desired educational environment for the student. This paper highlights the need to understand the components of distance education and the properties of the Internet before embarking upon a distance education programme via the Internet: the Virtual University. The paper summarises some of the experiences of the Open University in this field and reports on areas needing further research such as tutoring (problem-solving sessions) and electronic learning/teaching materials (development).
Learning “from” or “through” the Web
Authors: Casey Des
Published: July 2004

Much of our human learning involves some form of face to face communication between those that learn and those that teach. The World Wide Web has become a medium of education in recent times and a number of models of learning have been used in teaching via the Web. It is argued that any models so used need to include a significant element of human interaction, otherwise such models will be less than satisfactory for a significant proportion of the learning population.
Why do students take programming modules?
Authors: Curzon Paul , Rix Janet
Published: July 2004

Programming jobs are increasingly scarce and yet an increasing number of students are taking IT and computing courses containing programming. It may therefore be that many will never need to write programs themselves. Instead the knowledge and skills may be primarily of indirect use in other IT areas. If being able to program is not the ultimate objective of students taking such modules, then the aims and objectives of curriculum developers may need to be changed accordingly. In this paper, we investigate the motivations that University students have for taking programming modules, and look at how those motivations change over time.
On animation features of Excel
Authors: Dybdahl Arne , Sutinen Erkki , Tarhio Jorma
Published: July 2004

We consider how to create animations with Microsoft Excel. We present the capabilities of the drawing and auditing tools, dynamic graphs, and special effects of cells. Combining these features with the integrated Visual Basic programming language provides the user with an easy-to-use platform for versatile educational visualisations.
Multimedia education—quo vadis?
Authors: Gonzalez Ruben , Cranitch Greg
Published: July 2004

This paper presents some of the issues we have encountered in the development and implementation of Australia's first undergraduate degree in Multimedia within a faculty of Engineering and Applied Science. It is designed to stimulate discussion about the academic directions of multimedia undergraduate education. As a means to achieving this, the paper will present an overview of three levels of multimedia activity and an overview of current research areas in multimedia. This paper then assesses the likely intellectual tools required by graduates in multimedia to ensure the long-term viability of their learning during the undergraduate degree. Finally some possible directions will be presented for further discussion.
A constructivist framework for integrating the Java paradigm into the undergraduate curriculum
Authors: Hadjerrouit Said
Published: July 2004

The educational use of Java at the introductory level is still in its infancy and effective teaching strategies are only beginning to emerge. Java is a new technology designed to promote a new computing paradigm. To produce a new generation of students skilled in Java, undergraduate computer science should be taught from the perspective of developing a strong Java foundation. This paper describes a pedagogical framework motivated by principles found in the constructivist learning theory for integrating the Java paradigm into the undergraduate curriculum.
On-line journal
Authors: Riser Robert , Gotterbarn Donald
Published: July 2004

This paper discusses the development of a web-based on-line journal to replace a traditional project journal in a writing intensive undergraduate software engineering course. The on-line journal allows students to conveniently maintain their project journals while allowing the instructor to more effectively review student journals and provide timely feedback.
An augmented induction for HND computer studies students through an early integrated, inter-disciplinary assignment
Authors: Rosen C. , Simper D. , Bostock J. I.
Published: July 2004

Poor progression rates on the first year of the Higher National Diploma (HND) Computer Studies at the University of Derby have been a significant issue for the department for several years. Problems were attributed to the modular nature of the course and a lack of social skills on the part of the students. The course was modified by introducing a three week programme at the beginning of the course which integrated the Systems Analysis, Introductory Programming and Fundamentals modules. The approach was designed to improve progression rates by breaking down barriers both between students, and between course modules. It also aimed to facilitate the transition from further to higher education by providing a more structured induction and a more closely managed initial experience for the students.
JavaScript as a first programming language for multimedia students
Authors: Ward Robert , Smith Martin
Published: July 2004

Whilst there has been much discussion of Java as a first programming language, JavaScript has been comparatively ignored. This paper argues the merits of JavaScript as a first programming language for Multimedia students. It then describes the content of modules that use this approach, and reports experiences and findings on first delivery. As a result of positive experiences we are now planning to use JavaScript as precursor to Java for mainstream Computing students.
A multimedia C programming course that supports different learning situations (poster)
Authors: Moore Simon , Spink Martyn
Published: July 2004

A colour-coded framework for organising material in a multimedia C programming course is described. Together with maps of the 'solar-system' of material, the framework allows users to choose a variety of routes through the material. This allows students to tailor the course to their needs.
Formal modeling and analysis of the HLA component integration standard
Authors: Allen Robert J. , Garlan David , Ivers James
Published: July 2004

An increasingly important trend in the engineering of complex systems is the design of component integration standards. Such standards define rules of interaction and shared communication infrastructure that permit composition of systems out of independently-developed parts. A problem with these standards is that it is often difficult to understand exactly what they require and provide, and to analyze them in order to understand their deeper properties. In this paper we use our experience in modeling the High Level Architecture (HLA) for Distributed Simulation to show how one can capture the structured protocol inherent in an integration standard as a formal architectural model that can be analyzed to detect anomalies, race conditions, and deadlocks.
Applying design patterns to decision tree learning system
Authors: Masuda Gou , Sakamoto Norihiro , Ushijima Kazuo
Published: July 2004

In this paper we describe an application of design patterns to the development of a decision tree learning system. A decision tree learning system constructs a classifier as a form of tree from a given data set. It is required to be as flexible as possible when used in real application domains. Design patterns help us construct reusable software components and construct flexible and extensible systems. The approach employed in this study is as follows. First we examine several decision tree learning systems and identify
hot-spots
in the systems at points we anticipate future demand for modification and extension of the system. Second we determine which design pattern to apply to each
hot-spot.
We evaluate the extensibility of the system experimentally. Our experience shows that using design patterns in object-oriented software design allows the easy construction of flexible systems.
The architecture of Montana
Authors: Karasick Michael
Published: July 2004

Montana is an open, extensible integrated programming environment for C++ that supports incremental compilation and linking, a persistent code cache called a CodeStore, and a set of programming interfaces to the CodeStore for tool writers. CodeStore serves as a central source of information for compiling, browsing, and debugging. CodeStore contains information about both the static and dynamic structure of the compiled program. This information spans files, macros, declarations, function bodies, templates and their instantiations, program fragment dependencies, linker relocation information, and debugging information.Montana allows the compilation process to be extended and modified [11]. Montana has been used as the basis of a number of tools [1,7], and is also used as the infrastructure of a production compiler, IBM's Visual Age C++ 4.0 [8].
Filter-based model checking of partial systems
Authors: Dwyer Matthew B. , Pasareanu Corina S.
Published: July 2004

Recent years have seen dramatic growth in the application of model checking techniques to the validation and verification of correctness properties of hardware, and more recently software, systems. Most of this work has been aimed at reasoning about properties of complete systems. This paper describes an automatable approach for building finite-state models of partially defined software systems that are amenable to model checking using existing tools. It enables the application of existing model checking tools to system components taking into account assumptions about the behavior of the environment in which the components will execute. We illustrate the application of the approach by validating and verifying properties of a reusable parameterized programming framework.
A conversation about computer science education
Authors: McCracken Daniel D. , Frailey Dennis J.
Published: July 2004

This discussion began as an invitation to comment on the advisability of replacing some of the study of data structure implementation in CS2. It broadened into a discussion of a number of other aspects of computer science education. Dennis Frailey writes from an industrial point of view, although he also teaches computer science on an adjunct basis and was once a full-time academic. Dan McCracken writes from an academic point of view, although he has also worked in industry.
Systems architecture
Authors: Grinter Rebecca E.
Published: July 2004

The production of large and complex systems usually requires the coordination and collaboration of many individuals spread among numerous divisions of a corporation. However, much research examining coordination has focused on the subtleties of interactions between individuals who may work together in the same department. In this paper, I present a study of systems architects and the work that they do to coordinate design across organizational and institutional boundaries. I also describe the processes and tools that the architects use to support their work. The implications of the social processes involved in coordinating the design of large complex systems on the product and those involved in its production are discussed.
Virtual enterprise co-ordinator—agreement-driven gateways for cross-organisational workflow management
Authors: Ludwig Heiko , Whittingham Keith
Published: July 2004

Today's Workflow Management Systems (WfMS) do not distinguish between an external view of a process that is visible outside the organisation and its internal details. Their interfaces are generally aimed at the internal user. This is a problem if one organisation (provider) wants to perform a process on behalf of another (requester) so that it can be initiated and accessed by the requester through an automated interface and, vice versa, that the results can be reported back.This issue gains importance as WfMS are in widespread use today and the trend to outsource non-core business leads to increased service activity between companies. Organisations do not want to make internal information generally available to business partners nor do they wish to restrict their ability to conduct business internally. If organisations enter a business relationship, they define in an agreement the circumstances in which the requester might initiate a process in the provider and exchange further information during the process's performance.This paper describes the Virtual Enterprise Co-ordinator (VEC), a concept for the setup and management of gateways to WfMS-enacted processes for outside organisations on the basis of simple agreements. Using VEC, organisations can provide external partners with a controlled way of accessing WfMS-enacted processes, while retaining the freedom to change the internal details of those processes.
“Got COCA?” A new perspective in building electronic meeting systems
Authors: Li Du , Wang Zhenghao , Muntz Richard R.
Published: July 2004

In a previous paper[11], we presented COCA (Collaborative Objects Coordination Architecture) as a generic framework for developing collaborative systems. COCA advocates separation of coordination policies from general-purpose computations in collaborative systems so that the former can be modeled in a high-level specification language. Reuse of both coordination policies and collaboration tools can be achieved.This paper overviews the COCA model and focuses on the application of COCA in building real-life systems. We prototyped a modest set of tools for electronic meeting systems (EMSs) to show how they can be used to support both unstructured and structured meetings, with only changes in the coordination policies and no changes to the tools themselves. A subset of Robert's Rules of Order[21] was formalized and specified as an example of control of formal structured meetings. Finally the current status and the future directions are summarized.
WWAC
Authors: Bose Prasanta , Zhou Xiaoqing
Published: July 2004

Distributed engineering of complex software artifacts require collaboration of multiple
independent
stakeholders over extended periods of time. The independent decision changes, task executions, resource usages and other activities of the stakeholders may interact causing problems where mutual dependencies exist due to global activity ordering, resource sharing, product integrity, and other global constraints. Stakeholder coordination is required to ensure satisfaction of the global constraints. The paper presents an approach (WWAC) to the problem of stakeholder coordination for distributed design decision making that exploits an active meta-model arising out of stakeholder collaboration and captures abstractions of design decisions and their dependencies.
Supporting the writing of reports in a hierarchical organization
Authors: Girgensohn Andreas
Published: July 2004

In many hierarchical companies, reports from several independent groups must be merged to form a single, company-wide report. This paper describes a process and system for creating and structuring such reports and for propagating contributions up the organization. The system has been in regular use, in-house, by about 30 users for over a year to create monthly status reports. Our experiences indicate that it is possible to change a monthly reporting practice so that the system is easy to use, improves the quality of the written report, fosters collaboration across projects and creates a corporate memory for the company. These results were achieved as a consequence of our design effort to directly support the hierarchical and collaborative process of creating and assembling the report within the organization. User feedback has led to many improvements in the usability and functionality of the system. Further enhancements using information retrieval and text summarization techniques are in progress.
A configuration management approach for large workflow management systems
Authors: Schuster Hans , Neeb Jens , Schamburger Ralf
Published: July 2004

Scalability to large, heterogeneous, and distributed environments is an important requirement for workflow management systems (WfMS). As a consequence, the management of the configuration of a WfMS installation becomes a key issue. This paper proposes an approach for managing the configuration of WfMS together with an assignment strategy for workflow instances. Separating the logical issues of the workflow model from the physical configuration of a WfMS is the basis of our strategy. A formalization of physical organizational requirements in a WfMS configuration covering access rights, usage policies, and costs for the access to WfMS servers is presented and used in the assignment strategy for workflow instances. The results of our approach fit well for many existing WfMS and also for the reference architecture of the Workflow Management Coalition.
The design of an interactive online help desk in the Alexandria Digital Library
Authors: Prince Robert , Su Jianwen , Tang Hong , Zhao Yonggang
Published: July 2004

In large software systems such as digital libraries, electronic commerce applications, and customer support systems, the user interface and system are often complex and difficult to navigate. It is necessary to provide users with interactive online support to help users learn how to effectively use these applications. Such online help facilities can include providing tutorials and animated demonstrations, synchronized activities between users and system supporting staff for real time instruction and guidance, multimedia communication with support staff such as chat, voice, and shared whiteboards, and tools for quick identification of user problems. In this paper, we investigate how such interactive online help support can be developed and provided in the context of a working system, the Alexandria Digital Library (ADL) for geospatially-referenced data. We developed an online help system, AlexHelp!. AlexHelp! supports collaborative sessions between the user and the librarian (support staff) that include activities such as map browsing and region selection, recorded demonstration sessions for the user, primitive tools for analyzing user sessions, and channels for voice and text based communications. The design of AlexHelp! is based on user activity logs, and the system is a light-weight software component that can be easily integrated into the ADL user interface client. A prototype of AlexHelp! is developed and integrated into the ADL client; both the ADL client and AlexHelp! are written in Java.
The roles of a SQA person
Authors: Buckley F. J.
Published: July 2004

This paper identifies the three major roles of an SQA (Software Quality Assurance) professional, discusses the major obstacles encountered in performing each role, and provides recommendations to alleviate the associated difficulties.
Spreadsheet programs in software engineering
Authors: Kokol P.
Published: July 2004

Spreadsheet programs are an electronic equivalent of three nearly universal problem solving tools: a pencil, a sheet of paper and a calculator. Decisions, comparing different strategies, optimization and testing "what-if" questions are easy with using spreadsheet programs so they can be successfuly used in software engineering too. In the article we have showed the applications of spreadsheet softwre in estimating project costs and measurement of complexity or difficulty of software systems.
Prototype software complexity metrics tools
Authors: Cook C. C. , Nanja M.
Published: July 2004

Software Complexity Metrics Tool (SCMT) is a prototype, menu-driven program that assists in the collection, analysis, and display of software complexity and program error data. For example, using SCMT a user can investigate relationships between software complexity metrics and the number of errors in a program or can begin to develop predictive models for identifying error-prone modules.SCMT is written in C and runs under UNIX™. Although designed specifically for C software, its concepts and techniques apply to software in any programming language.
Experimenting with tail-recursion and simulating coroutines
Authors: Revesz Gyorgy E.
Published: July 2004

The efficiency of tail recursion and the simplicity of its removal makes some people wonder why we cannot transform all recursive definitions to this form? Clearly, the usual trick of introducing a new variable and using it as an accumulator to hold the intermediate results during the winding phase does not always work. But, by trying to generalize this technique to primitive recursion one can easily find a sufficient condition which makes it work. The class of functions satisfying this condition may be interesting also on its own. A direct generalization of this function class for mutual recursion is fairly straightforward.
Escaping the software tar pit
Authors: Boehm Barry
Published: July 2004

"No scene from prehistory is quite so vivid as that of the mortal struggles of great beasts in the tar pits… Large system programming has over the past decade been such a tar pit, and many great and powerful beasts have thrashed violently in it…"Everyone seems to have been surprised by the stickiness of the problem, and it is hard to discern the nature of it. But we must try to understand it if we are to solve it."Fred Brooks, 1975Several recent books and reports have confirmed that the software tar pit is at least as hazardous today as it was in 1975. Our research into several classes of models used to guide software development (product models, process models, property models, success models), has convinced us that the concept of model clashes among these classes of models helps explain much of the stickiness of the software tar-pit problem.We have been developing and experimentally evolving an approach called MBASE -- Model-Based (System) Architecting and Software Engineering -- which helps identify and avoid software model clashes. Section 2 of this paper introduces the concept of model clashes, and provides examples of common clashes for each combination of product, process, property, and success model. Sections 3 and 4 introduce the MBASE approach for endowing a software project with a mutually supportive set of models, and illustrate the application of MBASE to an example corporate resource scheduling system. Section 5 summarizes the results of applying the MBASE approach to a family of small digital library projects. Section 6 presents conclusions to date.
Object mappings in a software engineering project
Authors: Casey Richard M.
Published: July 2004

In a software engineering project, business objects were mapped directly to software and database objects. There was a natural correlation between objects in real world systems and their representation as software objects and database objects. This mapping may serve as an effective model for similar projects.
The senior information systems design project seminar
Authors: Sumner Mary
Published: July 2004

One of the challenges of teaching MIS is preparing students to apply the knowledge they have gained in a real project. Although they have developed proficiency in problem-solving, structured design techniques, and programming during course work, many MIS students have never interviewed a user or been asked to make design changes at a user's request. In addition, many students have never had to work on a project team, manage schedules, and meet project deadlines.

The senior information systems design project course provides students with an opportunity to apply systems concepts and techniques in the design of an information system. Students identify “live” projects and work on project teams. In the past, many of these projects have been programming design and implementation projects provided by local industry. However, in large-scale projects, students could not start with problem definition, proceed to requirements specification, and complete detailed design, because all of this could not be accomplished in a single term. As a result, they would do segments of larger projects.

With the advent of the microcomputer, however, many smaller scale projects became available in offices seeking to automate records management, routine accounting, and other office automation systems. These projects created an opportunity for students to do an entire project, from systems analysis to detailed design.

The purpose of this paper is to describe the objectives and procedures of the information systems design project seminar and to discuss the nature and scope of design projects conducted in university offices during the fall, 1985 quarter. The paper will describe the respective roles of student systems analysts and users, the systems development practices followed, and some of the successes and pitfalls of the experience.
A management system for monitoring and assessing the group-oriented database project
Authors: Pigford D. V.
Published: July 2004

This paper presents the evaluation techniques and forms for implementing group-oriented database projects in a senior level database course. A management system for monitoring the design, implementation, and testing of a small production database application using the team approach serves as the focus of this paper. Emphasis is upon both time and efficiency for students and instructor. The database prototype is implemented in phase one with a relational microcomputer tool and in phase two with a relational mainframe DBMS.
On the teaching of Ada in an undergraduate computer science curriculum
Authors: Tam Wing C. , Erlinger Michael A.
Published: July 2004

Traditionally beginning undergraduate computer science students are taught a high level programming language. Since the early 1970's Pascal has become the de facto standard introductory programming language. With the creation of Ada, its standardization, and the availability of validated compilers, there is considerable discussion concerning the introduction of Ada into the computer science curriculum. This paper discusses the approach taken by the Computer Science Department at Harvey Mudd College.
Fractals with turtle graphics: a CS2 programming exercise for introducing recursion
Authors: Liss Ivan B. , McMillan Thomas C.
Published: July 2004

This paper describes a programming exercise developed and used in CS2 classes to help introduce recursive programming. Providing a set of primitives which comprise a graphics system allows the students to focus on top down design and the nature of recursion, rather than on implementation details. The exercise entails drawing approximations of fractals by using the graphics primitives which are provided. The exercise was positively received by the students and provided a basis on which to discuss top down design and the desirability of hiding implementation details.
A Socratic approach to helping novice programmers debug programs
Authors: Wilson Judith D.
Published: July 2004

A technique is described which can be used to help novice programmers become more self-reliant in analyzing and debugging programs. The technique requires the instructor to interact one on one with students who seek help with their programs, and has been observed informally to have beneficial results for most of these students. Although the technique has not been tested experimentally, other experimental research involving novice programmers suggests that an approach of this kind should be effective.
The decline and fall of Operating Systems I
Authors: Shub Charles M.
Published: July 2004

This paper examines the changes in the undergraduate course on Operating Systems both from the perspective of the ACM curriculum recommendations and the perspective of the topical coverage in popular textbooks. It concludes that the course and the expectations of the course have changed over the years. The net effect of these changes has been towards less substance and less preparation for students emerging from the course. The paper begins by discussing the changes in ACM curricular guidelines. That section is followed by two sections that trace the changes recommended by the curricular guidelines to their implementations in both the older and newer generations of textbooks. These are followed by a brief discussion of the literature describing Operating Systems courses and their projects. Finally conclusions are drawn and recommendations are made.
Distribution of software engineering concepts beyond the software engineering course
Authors: Calhoun James
Published: July 2004

The importance of the role of documentation in the development and maintenance of software is not in dispute among computer professionals. Within the profession, software has come to mean more than just the source or object code which is produced. A modern definition of software includes documents as a vital component. The largest part of such documentation is external to the program and records the history of the project. Included could be project plans, requirements specification, preliminary detailed code design, user-directed manuals and maintenance journals.

All too often the computer science curriculum, whether by design or default, limits student experience with external documentation to specialized courses such as software engineering. While the documentation experience provided by these courses may prove valuable, its quality may be limited by the student's attitude. If the student's previous experience has been limited to internal documentation, there is a good chance that he has come to view documentation as an add-on, something to be completed after the project is really finished. It is difficult to alter this mind-set.

Identification of a solution to this problem may require not only a reevaluation of the documentation requirements for student software projects but an examination of the availability of programming languages and design tools which support the documentation effort. This paper reports the development of several design tools which are intended for student use in the preparation of preliminary project documentation. Special among these is an interactive graphics editor to be used to assist in the design, documentation and implementation of programs.
Bubble reflections
Authors: Zahn C. T.
Published: July 2004

A published version of Bubblesort is analyzed via correctness arguments and the failure of these arguments leads to the discovery of a subtle bug. A simple change produces a correct version and a not-so-trivial proof of termination completes the total correctness demonstration for the revised algorithm. Several important lessons are extracted from this experience.
An introductory algorithm teacher
Authors: Bulgren William G. , Marra Rose M. , Wetzel Gregory F.
Published: July 2004

A non-machine specific design of an algorithm teacher is proposed. It is a programmed environment to help students in a beginning computer science course learn problem solving skills. This paper provides an overview of the problem, a motivation and justification, followed by a brief description of what the program should provide the student.
Implementation of a debugging aid for logic errors in Pascal programs
Authors: Lukey Trevor , Loose Kenneth , Hill David R.
Published: July 2004

This paper describes a debugging utility with some tutorial capabilities. It is designed to assist novice programmers in finding logic errors in syntactically correct programs. Flow and use analysis techniques are employed to aid in the recognition of some instances of incorrect code sequence, improper variable use and improper nesting of constructs. The utility is menu driven with built in facilities for displaying user source programs and debugging information in a multiple window format.
Making concepts and phenomena visual in machine and assembly language programming
Authors: Decker William F.
Published: July 2004

Some courses in computer organization and assembly language programming have evolved away from ones emphasizing proficiency with a particular machine. Instead, these courses attempt to build understanding for the way in which abstract concepts are ultimately realized through machine level programming. The advent of small computers offers an opportunity to further personalize this form of instruction and to improve its delivery and availability. This paper discusses a package of software for use on personal computers which supports the teaching of courses in computer organization and assembly language programming. The software permits visualization of various abstractions, concepts, and phenomena. Examples of its use in teaching are examined, and related directions in teaching courses of this type are examined.
Profile of undergraduate software engineering courses: results from a survey
Authors: Mynatt Barbee , Leventhal Laura
Published: July 2004

A survey of undergraduate software engineering courses was conducted. The survey covered the issues of course level, course content, course organization, project characteristics and department demographics. The descriptive statistics show that the typical course focuses on the software development life cycle and includes a project intended for actual use. The project is carried out by teams of students, with student leaders. The issues of suitable textbooks, staffing, obtaining suitable software and sources of materials and training for teaching user-interface design surfaced as problem areas.
Extreme programming
Authors: Beck Kent
Published: July 2004

You can look at software development as a system with inputs and outputs. As with any system, software development needs negative feed-back loops to keep it from oscillating. The negative feedback loops traditionally used — separate testing groups, documentation, lengthy release cycles, reviews — succeed at keeping certain aspects under control, but they tend to have only long term benefits. What if we could find a set of negative feedback loops that kept software development under control, but that people wanted to do, even under stress, and that contributed to productivity both short and long term?
A fine-grained model for code mobility
Authors: Mascolo Cecilia , Picco Gian Pietro , Roman Gruia-Catalin
Published: July 2004

In this paper we take the extreme view that every line of code is potentially mobile, i.e., may be duplicated and/or moved from one program context to another on the same host or across the network. Our motivation is to gain a better understanding of the range of constructs and issues facing the designer of a mobile code system, in a setting that is abstract and unconstrained by compilation and performance considerations traditionally associated with programming language design. Incidental to our study is an evaluation of the expressive power of Mobile UNITY, a notation and proof logic for mobile computing.
Collaboration and composition
Authors: Warboys B. C. , Balasubramaniam D. , Greenwood R. M. , Kirby G. N. C. , Mayes K. , Morrison R. , Munro D. S.
Published: July 2004

Over the past decade a variety of process languages have been defined and applied to software engineering environments. The idea of using a process language to encode a software process as a “process model”, and enacting this using a process-sensitive environment is now well established. Many prototype process-sensitive environments have been developed; but their use in earnest has been limited. We are designing a second generation process language which is a significant departure from current conventional thinking. Firstly a process is viewed as a set of mediated collaborations rather than a set of partially ordered activities. Secondly emphasis is given to how process models are developed, used, and enhanced over a potentially long lifetime. In particular the issue of composing both new and existing model fragments is central to our development approach. This paper outlines these features, and gives the motivations behind them. It also presents a view of process support for software engineering drawing on our decade of experience in exploiting a “first generation” process language, and our experience in designing and exploiting programming languages.
Using model checking to generate tests from requirements specifications
Authors: Gargantini Angelo , Heitmeyer Constance
Published: July 2004

Recently, many formal methods, such as the SCR (Software Cost Reduction) requirements method, have been proposed for improving the quality of software specifications. Although improved specifications are valuable, the ultimate objective of software development is to produce software that satisfies its requirements. To evaluate the correctness of a software implementation, one can apply black-box testing to determine whether the implementation, given a sequence of system inputs, produces the correct system outputs. This paper describes a specification-based method for constructing a suite of
test sequences
, where a test sequence is a sequence of inputs and outputs for testing a software implementation. The test sequences are derived from a tabular SCR requirements specification containing diverse data types, i.e., integer, boolean, and enumerated types. From the functions defined in the SCR specification, the method forms a collection of predicates called
branches
, which “cover” all possible software behaviors described by the specification. Based on these predicates, the method then derives a suite of test sequences by using a model checker's ability to construct counterexamples. The paper presents the results of applying our method to four specifications, including a sizable component of a contractor specification of a real system.
Yesterday, my program worked. Today, it does not. Why?
Authors: Zeller Andreas
Published: July 2004

Imagine some program and a number of changes. If none of these changes is applied (“yesterday”), the program works. If all changes are applied (“today”), the program does not work. Which change is responsible for the failure? We present an efficient algorithm that determines the minimal set of failure-inducing changes. Our
delta debugging
prototype tracked down a single failure-inducing change from 178,000 changed GDB lines within a few hours.
Comparison checking
Authors: Jaramillo Clara , Gupta Rajiv , Soffa Mary Lou
Published: July 2004

We present a novel approach to avoid the debugging of optimized code through comparison checking. In the technique presented, both the unoptimized and optimized versions of an application program are executed, and computed values are compared to ensure the behaviors of the two versions are the same under the given input. If the values are different, the comparison checker displays where in the application program the differences occurred and what optimizations were involved. The user can utilize this information and a conventional debugger to determine if an error is in the unoptimized code. If the error is in the optimized code, the user can turn off those offending optimizations and leave the other optimizations in place. We implemented our comparison checking scheme, which executes the unoptimized and optimized versions of C programs, and ran experiments that demonstrate the approach is effective and practical.
Analyzing exception flow in Java programs
Authors: Robillard Martin P. , Murphy Gail C.
Published: July 2004

Exception handling mechanisms provided by programming languages are intended to ease the difficulty of developing robust software systems. Using these mechanisms, a software developer can describe the exceptional conditions a module might raise, and the response of the module to exceptional conditions that may occur as it is executing. Creating a robust system from such a localized view requires a developer to reason about the flow of exceptions across modules. The use of unchecked exceptions, and in object-oriented languages, subsumption, makes it difficult for a software developer to perform this reasoning manually. In this paper, we describe a tool called Jex that analyzes the flow of exceptions in Java code to produce views of the exception structure. We demonstrate how Jex can help a developer identify program points where exceptions are caught accidentally, where there is an opportunity to add finer-grained recovery code, and where error-handling policies are not being followed.
CoffeeStrainer
Authors: Bokowski Boris
Published: July 2004

Usually, programming languages are used according to conventions and rules. Although general rules can be enforced by lint-like tools, there is a large class of rules that cannot be built into such tools because they result from particular design decisions or the reuse of existing software. This paper presents a system, called CoffeeStrainer, that statically checks programmer-specified constraints on Java programs. Unlike previous approaches, which only support constraints that apply to definitions of types, CoffeeStrainer additionally supports a second class of constraints which apply to all uses of a type. Both classes of constraints play an important role for object-oriented class libraries and frameworks, which often make assumptions on their correct use.
Algebraic software architecture reconfiguration
Authors: Wermelinger Michel , Fiadeiro José Luiz
Published: July 2004

The ability of reconfiguring software architectures in order to adapt them to new requirements or a changing environment has been of growing interest, but there is still not much formal work in the area. Most existing approaches deal with run-time changes in a deficient way. The language to express computations is often at a very low level of specification, and the integration of two different formalisms for the computations and reconfigurations require sometimes substantial changes. To address these problems, we propose a uniform algebraic approach with the following characteristics.

Components are written in a high-level program design language with the usual notion of state.

The approach combines two existing frameworks—one to specify architectures, the other to rewrite labelled graphs—just through small additions to either of them.

It deals with certain typical problems such as guaranteeing that new components are introduced in the correct state (possibly transferred from the old components they replace).

It shows the relationships between reconfigurations and computations while keeping them separate, because the approach provides a semantics to a given architecture through the algebraic construction of an equivalent program, whose computations can be mirrored at the architectural level.
Transitioning legacy assets to a product line architecture
Authors: Bayer Joachim , Girard Jean-François , Würthner Martin , DeBaud Jean-Marc , Apel Martin
Published: July 2004

A successful software system evolves over time, but this evolution often occurs in an ad-hoc fashion. One approach to structure system evolution is the concept of software product lines where a core architecture supports a variety of application contexts. However, in practice, the high cost and high risks of redevelopment as well as the substantial investments made to develop the existing systems most often mandate significant leverage of the legacy assets. Yet, there is little guidance in the literature on how to transition legacy assets into a product line set-up.

In this paper, we present RE-PLACE, an approach developed to support the transition of existing software assets towards a product line architecture while taking into account anticipated new system variants. We illustrate this approach with its application in an industrial setting.
A GQM-based tool to support the development of software quality measurement plans
Authors: Abib Janaina C. , Kirner Tereza G.
Published: July 2004

This paper focuses on the Goal-Question-Metric (GQM) approach, which has been proposed as a goal-oriented approach for the measurement of products and processes in software engineering. First, the GQM is characterized, and then, the
GQM-PLAN
tool, is described. The
GQM-PLAN
was developed to support the preparation of measuring plans based on GQM.
Why softwarre fails
Authors: Whittaker James A. , Jorgensen Alan
Published: July 2004

This note summarizes conclusions from a three year study about why released software fails. Our method was to obtain mature-beta or retail versions of real software applications and stress test them until they fail. From an analysis of the causal faults, we have synthesized four reasons why software fails. This note presents these four classes of failures and discusses the challenges they present to developers and testers. The implications for software testers are emphasized.
Iambic IBM AI
Authors: Siegel Eric V.
Published: July 2004

In this paper, I describe an AI laboratory assignment in which students implement standard search techniques and explore heuristic measures of their own design for a palindrome discovery system. The system successfully derives palindromic sequences of words, many of which are meaningful, and achieves what is to the author's knowledge the first automatic generation of palindromes. Code is made available to students which implements the state space for palindrome search. This makes a large-scale problem accessible to introductory AI students by harnessing their knowledge of natural language. Students were motivated by the intrigue of discovering new palindromes.
Machine learning in the liberal arts curriculum
Authors: Congdon Clare Bates
Published: July 2004

Machine learning is typically considered a graduate-level course with an artificial intelligence course as a prerequisite. However, it does not need to be positioned this way, and in the liberal arts curriculum in particular, there are advantages to offering this course to undergraduate students. An undergraduate course in machine learning is easily and naturally structured to introduce research concepts and to work within a research paradigm. It also introduces the use of statistics, reflected both in the machine learning systems studied and in the experimental methodology. Furthermore, it allows for an interdisciplinary perspective, as students can be encouraged to work on problems from other departments in the college. This paper describes the benefits of offering such a course and outlines a course structure and resources for doing so.