bluuebunny/crossref_metadata_2025 huggingface dataset:
Techniques for improving language-based editors
Authors: Horgan J. R. , Moore D. J.
Published: July 2004

Syned is a working language-based editor which includes a complete parser for editing the C language. The design ideas which permit parsing in Syned also result in the solution of several important language-based editor problems. We describe these ideas in sufficient detail to make them accessible to others.
Graphical program development with PECAN program development systems
Authors: Reiss Steven P.
Published: July 2004

This paper describes the user's view of the PECAN family of program development systems. PECAN is a program development system generator for algebraic programming languages. The program development systems it produces support multiple views of the user's program, its semantics, and its execution. The program views include a syntax-directed editor, a declaration editor, and a structured flow graph editor. The semantic views include expression trees, data type diagrams, flow graphs, and the symbol table. Execution views show the program in action and the stack contents as the program executes. PECAN is designed to make effective use of powerful personal machines with high-resolution graphics displays and is currently implemented on APOLLO workstations.
Arcturus
Authors: Standish Thomas A. , Taylor Richard N.
Published: July 2004

The Arcturus system demonstrates several important principles that will characterize advanced Ada programming support environments. These include conceptual simplicity, tight coupling of tools, and effective command and editing concepts. Arcturus supports interactive program development and permits the combined use of interpretive and compiled execution. Arcturus is not complete however, as practical, mature environments for Ada must also support the development, analysis, testing, and debugging of concurrent programs. These issues are currently being explored. Arcturus, therefore is a platform for experimental exploration of key programming environment issues. This paper focuses primarily on the current system, describing and illustrating some of its components, while issues less fully developed are more briefly described.
The SAGA project
Authors: Campbell Roy H. , Kirslis Peter A.
Published: July 2004

The SAGA (Software Automation, Generation, and Administration) project is investigating formal and practical aspects of computer-aided support for the software lifecycle [Campbell and Richards, 81]. The goal of the project is to design a practical software development environment that supports and aids management of all major phases of the lifecycle. This paper presents requirements for a software development environment and shows how they are guiding the specification and design of the SAGA project. We review the goals of the project, and give an overview of the organization, design, and status of the major components of the SAGA software development system for which prototypes have been built. These components include a table-driven LR parser-based language-oriented editor, a discussion forum, a source code control system, and an incremental compilation facility.
Computer-Aided Software Engineering in a distributed workstation environment
Authors: Leblang David B. , Chase Robert P.
Published: July 2004

Computer-Aided Software Engineering environments are becoming essential for complex software projects, just as CAD systems have become essential for complex hardware projects. DSEE, the DOMAIN Software Engineering Environment, is a distributed, production quality, software development environment that runs on Apollo workstations. DSEE provides source code control, configuration management, release control, advice management, task management, and user-defined dependency tracking with automatic notification.

DSEE incorporates some of the best ideas from existing systems. This paper describes DSEE, contrasts it other systems, and discusses some of the technical issues involved in the construction of a highly-reliable, safe, efficient, and distributed development environment.
Implementing relational views of programs
Authors: Linton Mark A.
Published: July 2004

Configurations, versions, call graphs, and slices are all examples of
views
, or cross-sections, of programs. To provide a powerful mechanism for defining, retrieving, and updating these views, the OMEGA programming system uses a relational database system to manage all program information.

We have built a prototype implementation of the OMEGA-database system interface. This implementation includes the design of a relational schema for a Pascal-like language, a program for taking software stored as text and translating it into the database representation, and a simple, pointing-oriented user interface. Initial performance measurements indicate that response is too slow in our current environment, but that advances in database software technology and hardware should make response fast enough in the near future.
Document structure and modularity in mentor
Authors: Donzeau-Gouge V. , Kahn G. , Lang B. , Mélèse B.
Published: July 2004

Mentor is a structured document manipulation system. It has been used for several years as a program development and maintenance environment.

Its main characteristics are:

it is both interactive and programmable,

it is parameterized by the language to be manipulated,

it can manipulate several languages at the same time, as well as multi-lingual documents.

it is open to and from the outer system,

it is extensible.

The current development of Mentor reflects our belief that a major component of programming is the maintenance of large documents of a varied nature: specifications, programs, manuals, progress reports, documentation, etc... In addition, information of various kinds, and in different languages, is often mixed in a single document, and one may have to extract this information selectively upon request (e.g. text, examples and formal specification in a manual, or instructions, comments and assertions in a program).
Preliminary experience with a configuration control system for modular programs
Authors: Estublier J. , Ghoul S. , Krakowiak S.
Published: July 2004

This paper describes some preliminary experience gathered during the implementation and early use of a program composition and version control system. This system has been designed and implemented as a part of the Adele research project, a programming environment for the production of modular programs (Estublier 83). This project has four main components: a) a program editor, interpreter and debugger; b) a parameterized code generator; c) a user interface; d) a program base, the subject of this paper. The current version of this environment has been developed on a Multics system.

The program base, including the system composition and version control mechanisms, has been used for six months, notably for its own development and maintenance.
Generation Scavenging
Authors: Ungar David
Published: July 2004

Many interactive computing environments provide automatic storage reclamation and virtual memory to ease the burden of managing storage. Unfortunately, many storage reclamation algorithms impede interaction with distracting pauses.
Generation Scavenging
is a reclamation algorithm that has no noticeable pauses, eliminates page faults for transient objects, compacts objects without resorting to indirection, and reclaims circular structures, in one third the time of traditional approaches.

We have incorporated
Generation Scavenging
in Berkeley Smalltalk(BS), our Smalltalk-80 implementation, and instrumented it to obtain performance data. We are also designing a microprocessor with hardware support for
Generation Scavenging
.
The program dependence graph in a software development environment
Authors: Ottenstein Karl J. , Ottenstein Linda M.
Published: July 2004

The internal program representation chosen for a software development environment plays a critical role in the nature of that environment. A form should facilitate implementation and contribute to the responsiveness of the environment to the user. The
program dependence graph (PDG)
may be a suitable internal form. It allows programs to be sliced in linear time for debugging and for use by language-directed editors. The slices obtained are more accurate than those obtained with existing methods because I/O is accounted for correctly and irrelevant statements on multi-statement lines are not displayed. The PDG may be interpreted in a data driven fashion or may have highly optimized (including vectorized) code produced from it. It is amenable to incremental data flow analysis, improving response time to the user in an interactive environment and facilitating debugging through data flow anomaly detection. It may also offer a good basis for software complexity metrics, adding to the completeness of an environment based on it.
A cognitively-based methodology for designing languages/environments/methodologies
Authors: Soloway Elliot
Published: July 2004

In designing a programming language, programming environment, or programming methodology there are a whole lot of both implicit and explicit “shoulds.” By a “should” we mean the claim that the appropriate use of language/environment/methodology X will lead to good habits and result in good products. For example, ADA's commitment to strong typing and mechanisms for constructing data types implies that these components are good and should result in more effective programming. The top-down design methodology implies that designers should start at the specifications and refine downward; this process will result in a good design. Etectera. The problem is that it is not clear that the current crop of languages/environments/methodologies (L/E/M's) do result in more productive programming and design, and that the “shoulds” implied by them are really all that good ([7]).
A study of protection in programming languages
Authors: Ambler Allen L. , Hoch Charles G.
Published: July 2004

The concept of “protection” in programming languages refers to the ability to express directly in the language the desired access control relationships for all objects defined in the language. The use of such mechanisms as
data types, scope, parameter passing
mechanisms,
routines as parameters, abstract data types,
and
capabilities
in Pascal, Concurrent Pascal, Euclid, Clu, and Gypsy are explored via a simple example which embodies many protection problems. The usefulness of language defined and enforced protection mechanisms to the process of formal verification is discussed.
Towards the ideal programming language
Authors: Herriot Robert G.
Published: July 2004

A programming language with good features and notation can help the programmer represent his abstractions in the programming language, and can also help someone else understand the original abstraction. There have been numerous proposals for better features. In this paper we propose several new ideas to improve the notation. First we suggest that class instances be named with a sequence of identifiers consisting of the class name preceded by modifiers. Then we propose that prepositions be placed before procedure parameters to suggest their role. Finally, we suggest that applicative and imperative operations can be separated semantically, and then recombined syntactically through the use of the “which” and passive operators.
Restricted data types, specification and enforcement of invariant properties of variables
Authors: Buckle Normand
Published: July 2004

When defining a data type, it is often useful to specify restrictions on the permitted values of that type.

Pascal's subrange type declaration, a special case of this kind of constraint definition, has already proved itself to be quite useful. Restricted data types allow more complex constraints to be defined and checked; for example, a variable could be declared of type “odd integer” or the day field of a “date” type variable could be checked for consistency with the year and month fields.

A simple mechanism is proposed, allowing the formulation of such constraints and their association with data types; the behaviour of a restricted type variable is described. The effects of the use of such a mechanism on program reliability, readability and efficiency are discussed.
An experimental investigation of the effect of program structure on program understanding
Authors: Love Tom
Published: July 2004

A within-subjects experimental design was used to test the effect of two variables on program understanding. The independent variables were complexity of control flow and paragraphing of the source code. Understanding was measured by having the subjects memorize the code for a fixed time and reconstruct the code verbatim. Also some subjects were asked to describe the function of the program after completing their reconstruction. The two groups of subjects for the experiment were students from an introductory programming class and from a graduate class in programming languages.

The major findings were that paragraphing of the source had no effect for either group of subjects but that programs with simplified control flow were easier for the computer science students to understand as measured by their ability to reconstruct the programs. The dependent variable, rated accuracy of their description of the programs functions, did not differ as a function of either independent variable.

The paper is concluded with a description of the utility of this experimental approach relative to improving the reliability of software and a discussion of the importance of these findings.
Abstraction mechanisms in CLU
Authors: Liskov Barbara , Snyder Alan , Atkinson Russell , Schaffert Craig
Published: July 2004

CLU is a new programming language designed to support the use of abstractions in program construction. Work in programming methodology has led to the realization that three kinds of abstractions, procedural, control, and especially data abstractions, are useful in the programming process. Of these, only the procedural abstraction is supported well by conventional languages, through the procedure or subroutine. CLU provides, in addition to procedures, novel linguistic mechanisms that support the use of data and control abstractions.

This paper provides an introduction to the abstraction mechanisms in CLU. By means of programming examples, we illustrate the utility of the three kinds of abstractions in program construction and show how CLU programs may be written to use and implement abstractions. We also discuss the CLU library, which permits incremental program development with complete type-checking performed at compile-time.
Student computer consultants for small business—A viable option
Authors: Rodgers Edward G.
Published: July 2004

Small business organizations represent a significant share of U.S. economic activity. Entrepreneurs in such organizations routinely make broad decisions which have a major impact on their businesses, yet they are plagued with making such decisions without adequate information. Decision support systems and information databases are normal resources available to decision makers in larger organizations, but the entrepreneur in the small business organization generally operates with little or no data processing or systems capability.
The perils of top-down design
Authors: Zahniser Richard A.
Published: July 2004

Classic top-down design, which defines the system as a set of subsets of progressively more detailed functions, is the primary technique used in defining software components during requirements definition. This early "design", enforced by two major standards, is frequently used to assign work to development teams, which sometimes has a DISASTROUS effect on the overall system development effort.
Source control using VM/SP and CMS
Authors: Murray John
Published: July 2004

This paper describes the Source Control System (SCS), an automated system which runs under IBM VM/SP with CMS. It is designed to manage source code data in medium-sized software development environments.
Software effort metrics: how to join them
Authors: Kokol P.
Published: July 2004

There are several software complexity metrics in use today. Halstead's software science, McCabe cyclomatic number and lines of code (LOC) are most popular of them. A great weakness of these metrics is that they measure different complexities for a given program. Thus, it will be very clever to join them. We have developed a model which combines above three metrics and present it in this paper.
A successful computer approach to the computer literacy course
Authors: Price Barbara A.
Published: July 2004

Much emphasis has been placed on the core curriculum for the computer science major and this topic has been the focus of reports by the ACM and prominent educators (1, 4). Little attention seems to have been given, until recently, to the needs of the student not wishing to major in computer science but desiring an introduction to the discipline and an exposure to some common applications of the computer. This could be handled by two courses, computer science for the non-major and computer literacy. However, limited resources prevent the offering of two such courses at our college and a single course meeting both needs, introduction to the discipline and computer literacy, has evolved. We shall refer to this course as the computer literacy course.
Taming architectural evolution
Authors: van der Hoek André , Mikic-Rakic Marija , Roshandel Roshanak , Medvidovic Nenad
Published: July 2004

In the world of software development
everything
evolves. So, then, do software architectures. Unlike source code, for which the use of a configuration management (CM) system is the predominant approach to capturing and managing evolution, approaches to capturing and managing architectural evolution span a wide range of disconnected alternatives. This paper contributes a novel architecture evolution environment, called Mae, which brings together a number of these alternatives. The environment facilitates an incremental design process in which all changes to all architectural elements are integrally captured and related. Key to the environment is a rich system model that combines architectural concepts with those from the field of CM. Not only does this system model form the basis for Mae, but in precisely capturing architectural evolution it also facilitates automated support for several innovative capabilities that rely on the integrated nature of the system model. This paper introduces three of those: the provision of design guidance at the architectural level, the use of specialized software connectors to ensure run-time reliability during component upgrades, and the creation of component-level patches to be applied to deployed system configurations.
An architectural style of product lines for distributed processing systems, and practical selection method
Authors: Morisawa Yoshitomi , Torii Koji
Published: July 2004

When implementing an application system in a distributed computing environment, several architectural questions arise, such as how and where computing resources are arranged, and how the communication among computing resources are implemented. To simplify the process of making these choices, we have developed an architectural style for distributed processing system. The style classifies product lines for distributed processing systems into nine categories based on the location of data storage and the style of processing between client and server. This paper describes our architectural style and proposes a simple but practical method to select an appropriate architectural style for developing an application system. We apply this selection method in concrete real application systems.
Automatic synthesis of deadlock free connectors for COM/DCOM applications
Authors: Inverardi Paola , Tivoli Massimo
Published: July 2004

Many software projects are based on the integration of independently designed software components that are acquired on the market rather than developed within the project itself. Sometimes interoperability and composition mechanisms provided by component based integration frameworks cannot solve the problem of binary component integration in an automatic way. Notably, in the context of component based concurrent systems, the binary component integration may cause deadlocks within the system. In this paper we present a technique to allow connectors synthesis for deadlock-free component based architectures [2] in a real scale context, namely in the context of COM/DCOM applications. This technique is based on an architectural, connector-based approach which consists of synthesizing a COM/DCOM connector as a COM/DCOM server that can route requests of the clients through a deadlock free policy. This work also provides guide lines to implement an automatic tool that derives the implementation of routing dead-lock-free policy within the connector from the dynamic behavior specification of the COM components. It is then possible to avoid the deadlock by using COM composition mechanisms to insert the synthesized connector within the system while letting the system COM servers unimodified. We present a sucessful application of this technique on the (COM version of the) problem known as
"The dining philosophers".
Depending on the type of deadlock we have a strategy that automatically operates on the connector part of the system architecture in order to obtain a suitably equivalent version of the system which is deadlock-free.
Modular verification of collaboration-based software designs
Authors: Fisler Kathi , Krishnamurthi Shriram
Published: July 2004

Most existing modular model checking techniques betray their hardware roots: they assume that modules compose in parallel. In contrast, collaboration-based software designs, which have proven very successful in several domains, are sequential in the simplest case. Most interesting collaboration-based designs are really quasi-sequential compositions of parallel compositions. These designs demand and inspire new verification techniques. This paper presents algorithms that exploit the software's modular decomposition to verify collaboration-based designs. Our technique can verify most properties locally in the collaborations; we also characterize when a global state space construction is unavoidable. We have validated our proposal by testing it on several designs.
An industrial case study of implementing software risk management
Authors: Freimut Bernd , Hartkopf Susanne , Kaiser Peter , Kontio Jyrki , Kobitzsch Werner
Published: July 2004

Explicit risk management is gaining ground in industrial software development projects. However, there are few empirical studies that investigate the transfer of explicit risk management into industry, the adequacy of the risk management approaches to the constraints of industrial contexts, or their cost-benefit. This paper presents results from a case study that introduced a systematic risk management method, namely the Riskit method, into a large German telecommunication company. The objective of the case study was (1) to analyze the
usefulness and adequacy
of the
Riskit method
and (2) to analyze the
cost-benefit
of the
Riskit method
in this industrial context. The results of (1) also aimed at improvement and customization of the Riskit method. Moreover, we compare our findings with results of previous case studies to obtain more generalized conclusions on the Riskit method. Our results showed that the Riskit method is practical, adds value to the project, and that its key concepts are understood and usable in practice. Additionally, many lessons learned are reported that are useful for the general audience who wants to transfer risk management into new projects.
Modelling and managing software federations
Authors: Estublier J. , Verjus H. , Cunin P. Y.
Published: July 2004

Building large software applications from Commerical Off The Shelf tools (COTS) is not an industrial reality so far. This work presents a new approach to solve the different problems found when building a federation of COTS.
Aspect-oriented programming
Authors: Kiczales Gregor , Hilsdale Erik
Published: July 2004

Aspect-oriented programming (AOP) is a technique for improving separation of concerns in software design and implementation. AOP works by providing explicit mechanisms for capturing the structure of crosscutting concerns. This tutorial shows how to use AOP to implement crosscutting conerns in a concise modular way. It works with AspectJ, a seamless aspect-oriented extension to the Java(tm) programming language, and with AspectC, an aspect-oriented extension to C in the style of AspectJ. It also includes a description of their underlying model, in terms of which a wide range of AOP languages can be understood.
Half day tutorial in methods of component-based software engineering essential concepts and classroom experience
Authors: Wallnau Kurt , Hissam Scott , Seacord Robert C.
Published: July 2004

The question of which design methods are appropriate for component-based development (CBD) is complicated by different understandings of the end objectives CBD. A further complication is different understandings of what is meant by "component." These differences lead to entirely distinct classes of design problem. The aim of this tutorial is to, first, outline the differing interpretations of CBD, and, second, to outline the required methodological responses to these design problems.
Adapting XP to complex application domains
Authors: Lippert Martin , Roock Stefan
Published: July 2004

Extreme programming (XP) works well for small software projects in not-too-complex application domains. In many of these projects the rather simple requirements engineering of XP (customers write story cards) has proved suitable. But today we are more often faced with complex application domains in which the classical XP techniques will not suffice. The tutorial shows how to adapt extreme programming to complex application domains and to demanding development tasks. We focus mainly on the requirements engineering part and show how to enhance XP with interviews, scenarios and system visions. We also integrate the management perspective into the "planning game" reconciling this perspective to users' needs. We propose a set of best-practice methods we have used in a number of industrial high-risk projects for different complex application domains.
EasyWinWin
Authors: Grünbacher Paul , Boehm Barry
Published: July 2004

EasyWinWin is a requirements definitions methodology that builds on the win-win negotiation approach and leverages collaborative technology to improve the involvement and interaction of key stakeholders. With EasyWinWin, stakeholders move through a step-by-step win-win negotiation where they collect, elaborate, and prioritize their requirements, and then surface and resolve issues.
Requirements-based product line engineering
Authors: Mannion Mike , Kaindl Hermann
Published: July 2004

Reuse and requirements are very important for efficient and successful systems development. This tutorial presents the experiences of requirements reuse using a Method for Requirements Authoring and Management (MRAM). MRAM is a method for establishing and selecting from product line requirements. A product line is a group of products within the same market segment e.g. mobile phones. TRAM (Tool for Requirements Authoring and Management) is a software tool to support MRAM that utilises current proven office technology (MS-Word, MS-Access). The tutorial presents the results of MRAM/TRAM as it has been applied to product line engineering of a real-world application.
Process support for distributed team-based software development workshop
Authors: Tiako Pierre F. , Lindquist Tim , Gruhn Volker
Published: July 2004

This report summarizes the 2
nd
International Workshop on Process Support for Distributed Team-based Software Development held at the Sheraton World Resort of Orlando, Florida, on July 25, 2000 in conjunction with the Information Systems, Analysis and Synthesis (ISAS2000) International Conference. An overall twenty people attended the workshop consisting of seven technical presentations in two plenary sessions. In the following, we outline the presentations and subsequent discussions, which included modeling and distributing process component, evolution and change, web-based framework, consistency management, and reuse and interoperability.The hardcopy of the papers selected for PDTSD'00 are published by the International Institute of Informatics and Systemics as a part of the "
Industrial Systems
" volume of ISAS 2000, ISBN 980-07-6695-2.
From software requirements to architectures (STRAW01)
Authors: Castro Jaelson , Kramer Jeff
Published: July 2004

The First International Workshop From SofTware Requirements to Architectures (STRAW'01) was held in Toronto, Ontario, Canada, on May 14, 2001, just before the 23
rd
International Conference on Software Engineering (ICSE). In the following we give an overview of the motivation, goals, selection process and participation, workshop structure and activities, which includes a summary of presentations and discussions that took place during the workshop.
Customer involvement in extreme programming
Authors: van Deursen Arie
Published: July 2004

This paper covers customer involvement challenges in light-weight software development processes. The report summarizes the presentations and discussions of the
Workshop on Customer Involvement
held during XP2001, the
Second International Conference on Extreme Programming and Flexible Processes in Software Engineering,
Cagliari, Italy, May 21, 2001.
Generative techniques for product lines
Authors: Butler Greg
Published: July 2004

A software product line leverages the knowledge of one or more domains in order to achieve short time-to-market, cost savings, and high quality software. The highest level of reuse comes by using domain-specific languages or visual builders to describe a member of the product line, and to generate the member from the description. Generative techniques can help us to capture the configuration knowledge for a product line and use it to generate concrete family members. This workshop focuses on technical issues of product lines, rather than economic issues.
Connotations of problem solving
Authors: Srinivasa Srinath
Published: July 2004

A lot of interest has been focused on analysis and design models during information system (IS) design. But fundamentally, information systems are tools of "problem solving" where the term "problem solving" can take on different connotations. In this paper, we introduce seven different connotations of problem solving that describe IS functionality. Such a knowledge can help the system designer in transitioning between the analysis and design phases.
Summary report of the OOPSLA 2000 workshop on scenario-based round-trip engineering
Authors: Systä Tarja , Keller Rudolf K. , Koskimies Kai
Published: July 2004

This report summarizes the Workshop on Scenario-Based Round-Trip Engineering held in Minneapolis, Minnesota, USA, on October 16, 2000, in conjunction with the International Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA 2000). The workshop consisted of a keynote and seven presentations, which were organized into three sessions: From Interaction Diagrams to State Machines, Forward Engineering, and Reverse Engineering. Altogether nine position papers were accepted. The workshop web page, including the papers, the presentations, and the electronic version of this report, can be found at .
Perspectives on software product lines
Authors: Knauber Peter , Succi Giancarlo
Published: July 2004

Product line engineering is a concept that has emerged in the 80's in the business schools and is now among the hottest topics in software engineering.Software product lines aim at achieving scope economies through synergetic development of software products. Diverse benefits like cost reduction, decreased time-to-market, and quality improvement can be expected from reuse of domain-specific software assets. But also non-technical benefits can be expected as result of network externalities, product branding, and sharing organizational costs.Product lines introduce additional complexity. In a sense they go against the common adage of "divide and conquer." Planning and/or developing of more than one product at a time have to be managed technically and organizationally.However, the rate of innovation of the technology and the intrinsic nature of software products do not let alternatives to developers: users like to jump into the bandwagon of new products, and old products often drive preferences to new products.Research has been conducted in software product lines for the past few years. Some of it has focused on demonstrating that existing systems and approaches were indeed instrumental for product line development, such as generative techniques, domain analysis and engineering and software components. Another portion of the research effort has tried to determine how it is possible to create a comprehensive methodology and an associated tool for product lines, starting from the business idea of line of products down to the development of a product and trying to exploit all the possible synergies existing at each phase, from network externalities to component reuse.
Tracking software projects with the integrated version control in SMIT
Authors: Mihajlovic Zorica , Velasevic Dusan
Published: July 2004

The purpose of the software project tracking and oversight process is to provide visibility into actual progress so that management can take corrective actions when the project's performance deviates significantly from the plans. The sequence of the project's performances forms the project's change history. The new SMIT tool for planning and tracking software projects with the additional capability to process the project's change history is presented in the paper. This additional capability is based upon the integration of version control into the standard planning and tracking capabilities of the tool. It facilitates the project's post-mortem analysis and helps us to manage future projects. Since the history contains valuable data it enables us to learn from mistakes and good examples. Comparing two performances is the important type of processing the project's change history. SMIT accomplishes this type of processing in the context of tracking and thus surpasses the solution based on the standard tools for project management and version control. In addition, SMIT reduces the number of interactions needed to compare two performances from 61% to 88% for the example projects considered.
Assessing the state of the software process development using the chaos theory
Authors: Kokol Peter , Podgorelec Vili , Cardoso Ana Isabel , Dion Francis
Published: July 2004

Computer software and the software development process belong to the class of complex systems. As a consequence software development process can be analysed by techniques and concepts used in the chaos theory. It is the aim of this paper to present how we can use the chaos theory (in particular the Logistic map concept) to identify the state of the software development process.
Intellectual energy in software design
Authors: Kokol Peter , Podgorelec Vili , Dion Francis , de Loach Rich
Published: July 2004

In the paper we use the sequential study approach to empirical software engineering to research a novel idea about assessing the intellectual energy built into the software products. The study showed that we can use product of Function Points and α metric to calculate both the intellectual energy reflected in the software and the intellectual energy spend during the software design.
WoSEF
Authors: Sim Susan Elliot , Koschke Rainer
Published: July 2004

A workshop was held at ICSE 2000 in Limerick, Ireland to further efforts in the development of a standard exchange format (SEF) for data extracted from and about source code. WoSEF (Workshop on Standard Exchange Format) brought together people with expertise in a variety of formats, such as RSF, TA, GraX, FAMIX, XML, and XMI, from across the software engineering discipline. We had five sessions consisting of a presentation and discussion period and a working session with three subgroups. The five sessions were: 1) Survey and Overview, 2) Language-level schemas and APIs, 3) High-level schemas, 4) MOF/XMI/UML and CDIF, and 5) Meta schemas and Typed Graphs. During that time we reviewed previous work and debated a number of important issues. This report includes descriptions of the presentations made during these sessions. The main result of the workshop is the agreement of the majority of participants to work on refining GXL (Graph eXchange Language) to be the SEF. GXL is an XML-based notation that uses attributed, typed graphs as a conceptual data model. It is currently a work in progress with contributors from reverse engineering and graph transformation communities in multiple countries. There is a great deal of work to be done to finalise the syntax and to establish reference models for schemas. Anyone interested is welcome to join the effort and instructions on how to get involved are found at the end of the workshop report. Three papers from the workshop have been reprinted here to promote reflection and encourage participation in the work to develop an SEF.
Event-driven programming is simple enough for CS1
Authors: Bruce Kim B. , Danyluk Andrea P. , Murtagh Thomas P.
Published: July 2004

We have recently designed a CS 1 course that integrates event-driven programming from the very start. Our experience teaching this course runs counter to the prevailing sense that these techniques would add complexity to the content of CS 1. Instead, we found that they were simple to present and that they also simplified the presentation of other material in the course. In this paper, we explain the approach we used to introduce event-driven methods and discuss the factors underlying our success.
Teaching HCI with scenario-based design
Authors: Vat Kam Hou
Published: July 2004

This paper describes the application of scenario-based design in the teaching of Human-Computer Interaction (HCI), in an undergraduate Software Engineering program. Specifically, we describe how the ideas of constructivism can be synthesized with the team-based efforts in managing software requirements. The paper serves as an experience report of an ongoing action research the author has been executing to revise the curriculum and pedagogy of a junior core course entitled
Software Psychology.
In particular, we depict some problem scenarios, helping the evolution of the course content, and developing our students as self-directed work teams of software professionals. The paper concludes with the author's lessons learned with this course enactment plus the necessary reflective evaluations therein.
A student project in software evaluation
Authors: Czajkowski Michael F. , Foster Cheryl V. , Hewett Thomas T. , Casacio Joseph A. , Regli William C. , Sperber Heike A.
Published: July 2004

Properly educating computer scientists involves teaching effective means to properly engineer a system. An important part of such engineering work is ensuring that the computing system is both useful and usable. While many systems out there today are difficult to use, performing usability engineering on a system during its development has been shown to be an effective way to make a system more usable. The problem is fitting practical experience into the curriculum. This paper discusses a case example of how a team of undergraduate students learned to take a software system during its developing stages and perform effective usability engineering following the "thinking out loud" methodology.
Use of collaborative multimedia in computer science classes
Authors: Guzdial Mark
Published: July 2004

While there is a lot of speculation about the benefits of multimedia exploration, research on learning and technology suggests that the
creation
of media by students has even greater benefit for learning. Students learn through articulating their knowledge in their multimedia documents, reviewing their own work, and receiving comments and critiques on their work. In the research of the Collaborative Software Lab (http://coweb.cc.gatech.edu/csl), we are particularly interested in exploring the creation of media through collaborative technology. By having students work together in creating diverse media, we encourage review and critique, and create opportunities for joint learning. We have been using an environment for collaborative multimedia in several computer science classes, and in this paper, we describe some of the activities that teachers have invented for using the CoWeb.
Flexible delivery of information systems as a core MBA subject
Authors: Learmonth Rod
Published: July 2004

In terms of prior education, culture and life experience, a diverse student profile is evident in the intake into the Master of Business Administration (MBA) degree. Students may be experiencing tertiary education for the first time (industry experience entry) or adapting to a different education process (international students).In redeveloping the core MBA subject, Information Systems, materials were constructed to support student-driven "just in time" learning. This argues for an information age pedagogical model in which learning can occur with efficiency, at the student's own pace, anytime and at a location of their choosing. The paper outlines the teaching and learning context, delivery infrastructure and activities developed in response to this model.
Activating “black boxes” instead of opening “zipper” - a method of teaching novices basic CS concepts
Authors: Haberman Bruria , Kolikant Yifat Ben-David
Published: July 2004

In this paper we implement and evaluate of a unique instructional method for teaching basic concepts in computer science. This method is based on introducing a new concept through activating "black boxes" that demonstrate the properties of the concept and its role in the computing process. We used the "black box"-based instructional method to teach basic concepts of computation to novice high-school students. Later we conducted research aimed at assessing the effectiveness of this method on novice students' perceptions of basic concepts in computation. Research results indicated that students who learned according to the "black box"-based approach gained a better understanding of the basic computational model, compared to students who learned according to the traditional "zipper" approach.
The effect of student attributes on success in programming
Authors: Byrne Pat , Lyons Gerry
Published: July 2004

This paper examines the relationship between student results in a first year programming course and predisposition factors of gender, prior computing experience, learning style and academic performance to date. While the study does not suggest that any dominant attributes are related to success in programming, there are some interesting outcomes which will have implications for teaching and learning.
The motivation of students of programming
Authors: Jenkins Tony
Published: July 2004

Students approach the study of computing in Higher Education in increasing numbers from an increasingly wide variety of backgrounds. In most degree level courses one of the first modules students will encounter is intended to teach them to program.As the students become more diverse, so do their motivations for taking their degree. Anecdotal evidence from many institutions is that students are becoming more tactical, and will engage only in those activities that they see as contributing to an eventual highly paid job.This paper describes an investigation into the motivations of students for taking a degree in computing, and for studying programming in particular. The results raise a number of issues for the teaching of programming.
Is it okay to cheat? - the views of postgraduate students
Authors: Dick Martin , Sheard Judy , Markham Selby
Published: July 2004

This paper examines the attitudes of students in the Masters of Information Technology, Honours Degree in the Bachelor of Computing and Graduate Diploma of Computing at Monash University. Students were surveyed on the acceptability of a variety of scenarios involving cheating and on their knowledge of the occurrence of these scenarios. The survey found a strong consensus amongst the students as to what was acceptable or unacceptable practice. The paper then examines the significance of these results for educators aiming to prevent cheating amongst their students. The study reported is part of a larger study currently being undertaken in the School of Computer Science and Software Engineering (CSSE) at Monash University.
Interaction factors in software development performance in distributed student teams in computer science
Authors: Hause Martha L. , Almstrum Vicki L. , Last Mary Z. , Woodroffe M. R.
Published: July 2004

This research in progress paper compares the characteristics of high and low performance distributed student teams doing software development in Computer Science. The distributed student teams were involved in a software development project that was part of a Computer Science course at two universities located in different countries.We developed a set of categories to examine the email communication of distributed student teams. This paper tracks the progression and changes in the categories coded for each team's communication throughout the project's timeline, particularly during key decision periods in the software development cycle.
Experiences teaching software engineering for the first time
Authors: Stevens K. Todd
Published: July 2004

This paper presents an approach to teaching a Software Engineering course, as well as significant feedback from the students who were enrolled in the first offering of the course using this approach. The course provided students with conceptual material as well as experience with a large project. Just teaching concepts or major topics, while important, is not sufficient; students need hands-on exposure to doing a large project in order to comprehend the complexity of building real systems. On the other hand a course cannot "teach" only a project because students need a conceptual framework, approaches, and techniques upon which to base the complexities of software engineering. The feedback from the students who took the first offering of the course provides useful information to anyone who teaches Software Engineering, in addition to instructors preparing to teach the subject for the first time.
Using animation of state space algorithms to overcome student learning difficulties
Authors: Ciesielski Vic , McDonald Peter
Published: July 2004

We describe an algorithm animation system for artificial intelligence search algorithms. We have identified a number learning difficulties experienced by students studying search algorithms and designed the animation system to help students to overcome these difficulties. As well as the usual single step mode for assistance in learning the individual steps of an algorithm, the system supports an innovative burst mode for visualising qualitative behaviour and facilitating comparisons between different algorithms and heuristic functions. The system has successfully been used in the classroom for 4 years and survey results indicate use of the system improves understanding. An empirical study comparing a group of 15 students using the animation system and 15 students who wrote programs for the algorithms revealed a generally similar level of understanding, however the animation group was better at dealing with questions about qualitative behaviour.
EVEGA
Authors: Khuri Sami , Holzapfel Klaus
Published: July 2004

This paper describes the package EVEGA (Educational Visualization Environment for Graph Algorithms) and possible ways of incorporating it into the teaching of algorithms. The tool is freely available, platform- and network-independent, and highly interactive. The tool is designed for three different groups of users: students, instructors, and developers. Interaction with EVEGA can be achieved through the exploration of existing default visualizations, through the direct manipulation of graphical objects, or through the implementation and visualization of new algorithms using existing classes.