bluuebunny/crossref_metadata_2025 huggingface dataset:
Patterns and pedagogy
Authors: Clancy Michael J. , Linn Marcia C.
Published: July 2004

In this paper, we review research results relating to the use of software design patterns and advocate knowledge integration perspectives on programming instruction. We also describe a number of components of instruction that would lead to more effective use of patterns and better integration of programming knowledge in general.
A case study of the static analysis of the quality of novice student programs
Authors: Mengel Susan A. , Yerramilli Vinay
Published: July 2004

Helping students to understand the quality of their programs is a difficult task hampered by the time instructors have for grading. When the number of programs to grade are in the hundreds, instructors may be able to handle dynamic analysis of the programs and possibly a cursory glance at the code itself. Automated solutions may appear attractive, but few exist in the literature. Further, not enough examples exist to help instructors choose what metrics would be useful for helping students to visualize how they program. In this study, a collection of static metrics data obtained with Verilog Logiscope is correlated to an estimate of program quality to determine which metrics would show students at least the instructor's idea of quality. The study results are encouraging and show that definite correlations exist so that static analysis is a viable methodology for assessing student work. Further work is considered to help to confirm the study's results and their practical application.
A CS1 maze lab, using joysticks and MIPPETs
Authors: Stone Don C. , Bergmann Seth , Baliga Ganesh , Berman A. Michael , Schmalzel John
Published: July 2004

We are designing a number of programming projects which utilize input/output devices, such as joysticks or a homebrewed board we call a MIPPET (Module for Input/Output Programming Projects Enhancing Teaching). These projects have been used or will be used in the closed labs of our CS1 course (taught in C++). The goal of these projects is to enhance student comprehension (by teaching objects with "real" objects) and student motivation (by providing "fun" projects). This paper focuses on an early project, where the student's program provides support for a human solving a maze.
Do we teach the right algorithm design techniques?
Authors: Levitin Anany
Published: July 2004

Algorithms have come to be recognized as the cornerstone of computing. Surprisingly, there has been little research or discussion of general techniques for designing algorithms. Though several such techniques have been identified, there are serious shortcomings in the existing taxonomy. The paper points out these shortcomings, reevaluates some of the techniques, and proposes a new, hierarchical classification scheme by grouping techniques according to their level of generality. A variety of examples from different areas of computing are used to demonstrate the power and flexibility of the taxonomy being proposed.
Gender stereotyping in a computer science course
Authors: Greening Tony
Published: July 2004

Stereotypes often assume an implicit role in many gender studies. This paper describes a study in which the internal validity of gender stereotypes in a computing course is explored. Students' self-perceptions and common research positions in the literature are compared to these stereotypes. The study offers results different from most located in the literature. Further work is therefore suggested by the outcomes of this research to determine if this represents a favourable shift in the way in which women approach the discipline.
Using visualization to teach parallel algorithms
Authors: Naps Thomas L. , Chan Eric E.
Published: July 2004

In this paper, we describe two related techniques for delivering instructional animations of parallel algorithms --- one that runs on a Microsoft Windows workstation and another that is Web-based. After discussing the techniques, we examine their use in two pedagogical settings --- one in which students merely watch the animations as an aid to achieving a better understanding of the algorithm and one in which students actively participate in constructing the animation. The former context is appropriate in a juniorsenior algorithms course where, because of time constraints, parallel algorithms are only one of several topics studied. The latter context is appropriate for a course dedicated to the study of parallel algorithms or for a senior capstone experience. We conclude the paper with an appraisal of the strengths and weaknesses of the techniques we have developed and with some indications of how these techniques could be extended in the future.
An interactive multimedia textbook for introductory computer science
Authors: Grillmeyer Oliver
Published: July 2004

A multimedia implementation of an introductory computer science text based on the LISP dialect Scheme, is described. The text,
Exploring Computer Science with Scheme
[4], is designed for beginning students who may have no prior experience using computers. The goal is to create an environment that facilitates learning of the material and concepts in the text. The multimedia system includes hypertext abilities to jump through the text, search, and mark positions in the text. A personal notebook facility is provided that allows the user to enter notes while using the system or to copy sections of the text or Scheme environment directly into the notebook. The tool provides an animation feature that illustrates how various list and applicative functions work by modeling their internal actions. A Scheme listener is built into the tool to foster testing ideas and experimentation. Since the intended audience of the text includes people with no prior computing experience, the user interface is intuitive and full help features are provided.
Why? When an otherwise successful intervention fails
Authors: McCracken Michael , Waters Robert
Published: July 2004

Problem-Based Learning (PBL) has been an effective technique in developing self-directed learning and problem-solving skills in students --- especially in the medical school environment. This paper looks at some preliminary results of an ethnographic study of students in a software development environment trying to use PBL. Our findings indicate that students need explicit training in group dynamics, students tend to rely excessively on existing knowledge, and they focus almost solely on product-related issues versus process-related ones. We then present some suggested improvements and future planned research.
Interaction processes in network supported collaborative concept mapping
Authors: Chiu Chiung-Hui , Huang Chun-Chieh , Chang Wen-Tsung , Liang Tsung-Ho
Published: July 2004

This study investigated group interaction processes in network supported collaborative concept mapping, and the influence of these group interaction processes upon the group concept mapping performance. A total of 36 in-service teachers and pre-service student teachers engaged in this study. It was found that group concept mapping performance was significantly correlated to the quantity of group interaction, particularly high-level interaction processes. Suggestions for a further improvement in the system design to support collaborative concept mapping are also provided in this paper.
Laboratory experiment with the 3RolesPlaying method
Authors: Bobkowska Anna
Published: July 2004

The paper addresses the problem of making experiments for software engineering during laboratories. There is a need for experimental investigations. If experiments are performed in the lab together with training they must also have high educational value. In the paper, there is discussion about joining education and research. Then summary of the 3RolesPlaying method which satisfies goals of both of them is presented. Results of an experiment that took place in the Technical University of Gdansk, Poland in the summer semester of 1997/98 are described, and verification of the results value is made.
simpleIO
Authors: Wolz Ursula , Koffman Elliot
Published: July 2004

This paper describes how to incorporate user interactivity and graphics into a first course in computer science. Problems and alternative solutions are discussed. A Java package called simpleIO that we developed is presented. It allows novice programmers to build simple GUI -based programs while maintaining good design principles. The package includes methods for requesting data from the user including integers, reals, string and Booleans. It also supports simple menus, graphics displays and text file handling.
Creating digital libraries together—collaboration, multimodality, and plurality
Authors: Hedman Anders
Published: July 2004

Many have tried to answer the question of what a digital library is and how such libraries should be built. But, in a sense the question of how to construct digital libraries as well defined entities is misguided from the beginning. There are many approaches to building digital libraries [7, 18, 4] and each approach must be understood from within a context. Some contexts such as information retrieval and digitizing of existing materials have received much attention [12, 22, 18, 17], while other contexts have been more or less ignored [19]. One such context is that of networking from a higher level of abstraction [8, 11]. Since traditional libraries have long since existed in elaborate and large-scale physical networks it is only natural that we should see such structures mirrored in the world of digital abstract networks. The Universal Simulator [10] application builds on the idea that research in digital libraries need not necessarily focus on micro level infrastructures, but that we may also find interesting possibilities on the macro level of digital library infrastructures. Moreover, at such a macro level we may find important new ways of collaborating and building digital libraries in educational settings.
A constructivist approach to object-oriented design and programming
Authors: Hadjerrouit Said
Published: July 2004

Computer science education is greatly affected by the object-oriented approach. This can be seen in the numerous new teachers being attracted to programming languages such as Java. Learning the object-oriented approach is however difficult for novice students, mostly because it requires a new way of thinking about computing and more depth to grasp. Thus, to promote the object-oriented approach at the introductory level, a re-examination of the teaching method is recommended. This article describes a pedagogical framework rooted in the constructivist epistemology for teaching object-oriented design and programming.
A tool for designing Java programs with UML
Authors: Armentrout Anna
Published: July 2004

This project intends to develop a simple UML (Unified Modeling Language) tool in Java to be used by students learning object-oriented design and Java programming. Each student will be able to design a Java program by filling in forms (use cases, CRC cards) and making diagrams (use case diagrams, class diagrams and sequence diagrams) in a number of views. When the student enters information for any one of the views the tool will update the equivalent information for the other views. The tool will generate Java skeleton code from information supplied by the student.
On distance education courseware
Authors: Lomic Marijana , Putnik Zoran
Published: July 2004

Multimedia, WWW and advanced technologies are bringing changes in the field of education. Additional ways of interaction between students, study material, and teachers, are introduced. Development in technology and their introduction into education, changed the character and methods of it. A need exists for a distance education and additional education at home. With the cost of multimedia computers becoming lower, while availability of educational CD-ROM's higher, a proper inclusion of these into the curricula and distance education is needed. Here, some strategies for distance education software are being proposed.
Innovation in post graduate computer science education
Authors: Young Alison , Joyce Donald
Published: July 2004

This presentation will outline the progress to date of the development of the Master of Computing degree program, the courses developed, the philosophy behind the development, the structure including the exit qualification and the proposed delivery. It will also outline the quality assurance process and the very stringent accreditation process required before it is approved for delivery.
The visible Web browser
Authors: Gifford Atticus , Menasha Benjamin J. , Finkel David
Published: July 2004

As an aid to the study of the World-Wide Web, we have developed a software application that allows a user to observe the messages passed between a Web browser and a Web server. The application is based on the Mozilla Web Browser, and displays the HTTP headers sent and received by the browser. The program could be used by students in courses studying the Web, by researchers interested in the behavior of Web servers, and by developers to debug Web-based applications.
The synthesizer generator
Authors: Reps Thomas , Teitelbaum Tim
Published: July 2004

Programs are hierarchical compositions of formulae satisfying structural and extra-structural relationships. A program editor can use knowledge of such relationships to detect and provide immediate feedback about violations of them. The Synthesizer Generator is a tool for creating such editors from language descriptions. An editor designer specifies the desired relationships and the feedback to be given when they are violated, as well as a user interface; from the specification, the Synthesizer Generator creates a full-screen editor for manipulating programs in the language.
Language features for process interaction
Authors: Andrews Gregory R. , McGraw James R.
Published: July 2004

Languages for parallel programming should meet four goals: expressiveness, data integrity, security, and verifiability. This paper presents a set of language features for describing processes and process interaction, gives examples of their use, and briefly discusses their relation to the goals. Two constructs, resources and protected variables, are introduced as the mechanisms for describing interaction. Resources are extensions of the monitor concept of Hoare; protected variables are global variables which can only be accessed by one process at a time. Two types of access control are introduced: restrictions on scope rules for static access, and capabilities for dynamic access. Examples include the interface to machine devices, files and virtual devices, readers/writers, device scheduling, device reservation, and buffer allocation.
Process structuring, synchronization, and recovery using atomic actions
Authors: Lomet D. B.
Published: July 2004

This paper explores the notion of an atomic
action
as a method of process structuring. This notion, first introduced explicitly by Eswaren et al [6] in the context of data base systems, reduces the problem of coping with many processes to that of coping with a single process within the atomic
action
. A form of process synchronization, the
await
statement, is adapted to work naturally with atomic actions. System recovery is also considered and we show how atomic actions can be used to isolate recovery action to a single process. Explicit control of recovery is provided by a
reset
procedure that permits information from rejected control paths to be passed to subsequent alternative paths.
An experimental evaluation of data types on programming reliability
Authors: Gannon J. D.
Published: July 2004

The language in which programs are written can have a substantial effect on the reliability of the resulting programs. This paper discusses an experiment that compares the programming reliability of subjects using a statically-typed language and a “typeless” language. Analysis of the number of errors and the number of runs containing errors shows that, at least in one environment, the use of a statically-typed language can increase programming reliability. Detailed analysis of the errors made by the subjects in programming solutions to reasonably small problems shows that the subjects had difficulty manipulating the representation of data.
Computer science vs. software engineering
Authors: Zahniser Rivhard A.
Published: July 2004

What's the difference between Computer Science and Software Engineering? The Serendipity Principle gives us the answer.
Post-mortem analysis of software engineering at Wang Institute
Authors: Fairley Richard E.
Published: July 2004

This paper contains the text of invited presentation by the author at the Software Engineering Education Conference, which was held in Pittsburgh on April 30 and May 1, 1987. Topics presented here include an overview of the Wang Institute programs in software engineering, an analysis of the strengths and weaknesses of the Master of Software Engineering curriculum, and a discussion of reasons for termination of the software engineering education programs at Wang Institute of Graduate Studies.
Ada tasking model and Prolog predication
Authors: Ncube Cathy C.
Published: July 2004

This paper is a comparative analysis of the semantics of the Ada tasking model and the Prolog predication. The features analyzed are communication and synchronization, matching and unification, error handling, procedure dependencies, shared variables, logical inferences and concurrency. Distinctions between the features of tasking and predication reveal complimentary qualities. It is observed that increased effectiveness and efficiency result when the capabilities of these features are combined.
A case study in test environment evolution
Authors: Donnelly K. F. , Gluck K. A.
Published: July 2004

As the demand for increasingly complex software systems grows, and our software development environments become increasingly sophisticated in response, our testing technology must keep pace. This paper describes the evolution of one software testing environment and the genesis of its logical successor.
pastel
(PICS Automated System Testing Environment for Leap) originated over a decade ago, with an interpreter for a simple testing language used on a single project by a group of about ten people. As the demands of testing very large systems grew,
pastel
's functionality expanded. Today's
pastel
includes facilities for creating a test by simply exercising the system under test, for running the test in a variety of modes, and for capturing and automatically analyzing test results.
pastel
allows application experts to create tests easily; no sophisticated programming skill is required.
pastel
is now used by projects throughout the Software Technology and Systems Area of Bell Communications Research.
pastel
is a relatively mature product, an adequate testing system for the monolithic database systems it was intended to exercise.
astra
, its successor, is now being designed to test systems of interacting systems built on different sizes and flavors of hardware. This paper reviews the evolution of
pastel
and the preliminary design work and unifying concepts underlying
astra
.
A framework for incremental progress in the application of AI to software engineering
Authors: Arango Guillermo , Baxter Ira , Freeman Peter
Published: July 2004

The study of the potential contributions of artificial intelligence (AI) to software engineering (SE) needs a conceptual framework within which to analyze the scope and feasibility of such contributions.We propose a framework designed to uncover opportunities for incremental progress in SE through the adoption of AI solutions. We emphasize
incremental
for we believe progress must be assessed in terms of discrete, well-defined steps. The incremental approach involves two fundamental steps:1. partition the universe into restricted domains of study, and2. examine each of those domains to determine what progress is possible.The framework can be used as a guideline for refining research domains, as a context for comparing applications, or as a mechanism to provide structure for future discussions of applications of AI to SE.
Formalisms
Authors: Woodcock J. C. P.
Published: July 2004

At a previous workshop in this series at Orlando, there was a session on
Theory
; at this workshop there was a session on
Formalisms
. The difference is not just one of terminology: in the intervening three years many things have changed. Perhaps the key difference is that we now have much more experience in applying the results of the theoretical research in this area. We are now seeing formalisms being used on large projects, not just as part of a research activity, but also as part of the production of real products such as a silicon implementation of the IEEE floating point number system (INMOS), or the development of a large transaction processing system (IBM). Various formalisms---such as VDM, Z, CSP, Larch, and LOTOS---are reaching maturity and are emerging as today's standard tools for specification and design. These notations are formal in the sense that they are firmly based on
logic
and
mathematics
.
Microprocessor sequence revitalization
Authors: Mattis W. E.
Published: July 2004

The rationale for the revamping of microprocessor courses serving the Electrical Engineering and Computer Science Departments at Villanova University is described, including the choice of one processor for instruction, the sequencing of lecture material, and the development of a laboratory to reinforce the lecture material.
Comprehending the central limit theorem
Authors: Kerley Lyndell M.
Published: July 2004

Simulation will be used to illustrate the Central Limit Theorem and the concept of testing a hypothesis.
A graph based architectural (Re)configuration language
Authors: Wermelinger Michel , Lopes Antónia , Fiadeiro José Luiz
Published: July 2004

For several different reasons, such as changes in the business or technological environment, the configuration of a system may need to evolve during execution. Support for such evolution can be conceived in terms of a language for specifying the dynamic reconfiguration of systems. In this paper, continuing our work on the development of a formal platform for architectural design, we present a high-level language to describe architectures and for operating changes over a configuration (i.e., an architecture instance), such as adding, removing or substituting components or interconnectons. The language follows an imperative style and builds on a semantic domain established in previous work. Therein, we model architectures through categorical diagrams and dynamic reconfiguration through algebraic graph rewriting.
Combining UML and formal notations for modelling real-time systems
Authors: Lavazza Luigi , Quaroni Gabriele , Venturelli Matteo
Published: July 2004

This article explores a dual approach to real-time software development. Models are written in UML, as this is expected to be relatively easy and economic. Then models are automatically translated into a formal notation that supports the verification of properties such as safety, utility, liveness, etc. In this way, developers can exploit the advantages of formal notations while skipping the complex and expensive formal modelling phase. The proposed appraoch is applied to the Generalised Railroad Crossing (GRC) problem, one of the best known benchmarks porposed in the literature. A UML model of the GRC is built, and then translated into TRIO (a first order temporal logic). The resulting specification properties are tested by a history checking tool which exploits the formality of TRIO. The work described here highlights the shortcomings of UML as a real-time modelling language, proposes enhancements and workarounds to overcome UML limitations, and demonstrates the viability of using UML as a front-end for a formal real-time notation. By translating the GRC model into TRIO, we also give formal semantics to some of the UML constructs.
WREN---an environment for component-based development
Authors: Lüer Chris , Rosenblum David S.
Published: July 2004

Prior research in software environments focused on three important problems---tool integration, artifact management, and process guidance. The context for that research, and hence the orientation of the resulting environments, was a traditional model of development in which an application is developed completely from scratch by a single organization. A notable characteristic of component-based development is its emphasis on integrating independently developed components produced by multiple organizations. Thus, while component-based development can benefit from the capabilities of previous generations of environments, its special nature induces requirements for new capabilities not found in previous environments. This paper is concerned with the design of
component-based development environments
, or CBDEs. We identify seven important requirements for CBDEs and discuss their rationale, and we describe a prototype environment called WREN that we are building to implement these requirements and to further evaluate and study the role of environment technology in component-based development. Important capabilities of the environment include the ability to locate potential components of interest from component distribution sites, to evaluate the identified components for suitability to an application, to incorporate selected components into application design models, and to physically integrate selected components into the application.
An empirical methodology for introducing software processes
Authors: Shull Forrest , Carver Jeffrey , Travassos Guilherme H.
Published: July 2004

There is a growing interest in empirical study in software engineering, both for validating mature technologies and for guiding improvements of less-mature technologies. This paper introduces an empirical methodology, based on experiences garnered over more than two decades of work by the Empirical Software Engineering Group at the University of Maryland and related organizations, for taking a newly proposed improvement to development processes from the conceptual phase through transfer to industry. The methodology presents a series of questions that should be addressed, as well as the types of studies that best address those questions. The methodology is illustrated by a specific research program on inspection processes for Object-Oriented designs. Specific examples of the studies that were performed and how the methodology impacted the development of the inspection process are also described.
Software reuse antipatterns
Authors: Long John
Published: July 2004

Software reuse is a productivity technique attempted by many development organizations, with mixed success. In analyzing reuse failures, a number of antipatterns emerge. Antipatterns are obvious, but wrong, solutions to recurring problems. This article outlines a number of reuse antipatterns that have been observed within the software industry.
Product quality framework
Authors: Rangarajan Krishnan , Swaminathan N. , Hegde Vishu , Jacob Jacob
Published: July 2004

Quality focus is generally on process quality, the avoidance and elimination of defects. This is the most relevant for manufacturing processes. In engineering design, there is as much emphasis also on product quality aspects, such as availability, performance, usability, maintainability etc. Current systems and software engineering practice generally puts the burden of optimizing these attributes solely on the knowledge, intuition and ability of architects and designers.The product quality framework provides a systematic approach that includes techniques for specifying, optimizing, analyzing and measuring these attributes. The framework also puts explicit emphasis on tradeoffs between attributes, providing a direct relationship between design and customer concerns. This paper describes the framework and its use as a vehicle for the engineering of high availability systems.
Report on metrics 2001
Authors: Loconsole Annabella , Rodriguez Daniel , Börstler Jürgen , Harrison Rachel
Published: July 2004

This paper reports on the IEEE 7
th
International Software Metrics Symposium (METRICS 2001), held in London, England, from the 4
th
to 6
th
April 2001 and co-hosted with the 12
th
European Software Control and Metrics conference (ESCOM 2001). Metrics Symposia are the premier event in the area of software metrics and attract most of the leading researchers and industrial practitioners.
International workshop on software configuration management (SCM-10)
Authors: van der Hoek André
Published: July 2004

This report provides a brief summary of SCM-10, the ICSE 2001 10
th
International Workshop on Software Configuration Management. The primary goal of this workshop was to broaden the scope of SCM and establish ties with other disciplines that are strongly related to SCM---whether requiring some form of novel, advanced SCM functionality or influencing the field of SCM with newly available technology. As demonstrated by the accepted set of position papers and the lively discussion in the workshop, SCM-10 succeeded in achieving this goal and raised many new and important questions to be addressed in the years to come.
Workshop on software engineering and mobility
Authors: Roman Gruia-Catalin , Picco Gian Pietro
Published: July 2004

Mobility is redefining the hardware and software fabric of distributed systems. Wireless communication allows network hosts to participate in a distributed computation while on the move. Novel middleware technologies allow software components to migrate across hosts for enhanced flexibility or performance. Workshop participants were invited to analyze the software engineering implications of this wave of technological changes, by discussing fundamental models, emerging themes, research opportunities, technological trends, and market forces.http://www.elet.polimi.it/~picco/ICSE01mobility
2nd international workshop on living with inconsistency (IWLWI01)
Authors: Easterbrook Steve , Chechik Marsha
Published: July 2004

IWLWI-01
--- The Second International Workshop on Living with Inconsistency, took place in Toronto, Canada, on May 13, 2001 as part of ICSE-01. The following is a short overview of this workshop.
Dimensional modeling for a data warehouse
Authors: Dash Ashiss Kumar , Agarwal Rakesh
Published: July 2004

A multidimensional database stores data as groups of field category values into dimensions, and then groups these dimensions into multidimensional arrays. Specific field category values that may occur in data identify either the rows or columns of array dimensions. The specific grouped field categories themselves identify the row or column array dimensions. This view, when presented to the end user, bring in more relevance and business sense for practical decision making than the views presented by standard relational tables and flat file databases. On-Line Analytical Processing (OLAP) is based on the multidimensional representation of data which is supported by multidimensional databases, relational engines or a combination of both. In this paper we propose a model for multidimensional databases that we had used and implemented.
A software configuration management model for supporting component-based software development
Authors: Mei Hong , Zhang Lu , Yang Fuqing
Published: July 2004

Software configuration management (SCM) is viewed as an important key technology in software development and is being adopted in software industry more and more widely. And component-based software development (CBSD) is an emerging paradigm in software development. However, the traditional SCM method can not support CBSD effectively and efficiently. In this paper, we analyze the objects that need to be managed in CBSD and present a component-based SCM model to improve CBSD with effective SCM support. In this model, components, as the integral logical constituents in a system, are managed as the basic configuration items in SCM, and relationships between/among components are defined and maintained, in order to support version control of large objects and logical modeling of system architecture. Also some key issues in the model are discussed and an SCM system that supports this model is introduced.
A study of automatic migration of programs across the Java event models
Authors: Kumar Bharath M , Lakshminarayanan R. , Srikant Y. N.
Published: July 2004

Evolution of a framework forces a change in the design of an application, which is based on the framework. The same is the case when the Java event model changed from the Inheritance model to the Event Delegation model. We summarize our experiences when attempting an automatic and elegant migration across the event models. Further, we also necessitate the need for extra documentation in patterns that will help programs evolve better.
Agent-oriented analysis and modeling
Authors: PanYunhe Zhou Yonglin
Published: July 2004

Traditional requirements engineering (RE) are facing challenge. With the continuous change of application environment and software market, as well as the development of new design approaches (e.g. software architecture and component-based software engineering), RE should also move its eyes from product-oriented and function-centered view to problem-domain-oriented and structure-centered view. In this paper we proposed a new analysis and modeling approach : Agent-Oriented Approach (AOA). AOA is problem-domain-oriented and implementation-independent. It searches for a solution strategy for a families of problems rather than a special software requirements specification(SRS). It focuses on entities with active behavior in problem domain and pay attention to their interaction. It can describe parallel and distributed entities commonly existing in problem domains and it is more stable and reuseful than SRS.
Customizable output generation in modeling environments using pipelined domains
Authors: Milicev Dragan
Published: July 2004

Domain-specific modeling and metamodeling environments most often base their output generation capability on wizards, output templates, grammar-based transformers, or hard-coded output generators. The complexity of the specification process for such generators, and their dependence on the domain do not encourage customization, flexibility, and reuse. This paper proposes a solution to this problem. In the proposed approach, the domains are (meta) modeled using the standard object-oriented paradigm. Second, the generation of a model in the target domain from a model in the source domain is specified using extended UML object diagrams that allow specification of conditional, repetitive, and sequential creation of instances of the target domain's abstractions. Finally, the transformation of models may be performed in a pipelined fashion, where each domain model and mapping may be either created from the scratch or reused from the repository. This approach allows more efficient, incremental building of more abstract domains and their mapping into less abstract domains, because each transformation step is much less complicated to specify, maintain, and reuse. Furthermore, by simple choosing another pipeline, different versions of the ultimate implementation from the same initial high-level, user-defined model may be obtained automatically. A prototypal supporting tool has been implemented and briefly presented in the paper.
FASE
Authors: Bagert Donald J.
Published: July 2004

FASE (pronounced like "phase"), the Forum for Advancing Software
engineering Education, was started in 1991 by members of the
software engineering education community in order to have a
electronic forum for the dissemination and discussion of events
related to software engineering education. The original acronym for
FASE was Forum for Academic Software Engineering, but was
subsequently changed so that it was more inclusive to industrial
and government training issues (which led to a co-editor in that
area). In recent years, FASE has also covered a wide variety of
professional issues (e.g. licensing, certification, ethics, body of
knowledge, and accreditation), which has also led to the addition
of yet another co-editor for this area.FASE is an
independently-published newsletter, not affiliated with ACM,
IEEE-CS or any other organization. As of October 2000, 129 issues
have been published. Since August 1997, FASE has been published
monthly, and is released on the 15th of each month in ASCII format.
FASE has several hundred subscribers in over 50 countries and
provinces. There is also a FASE-TALK discussion list.The FASE web
page is at http://www.cs.ttu.edu/fase. It contains subscription
information, article submission guidelines, and an archive of all
FASE issues and FASE-TALK postings to date.The FASE Staff:

Thomas B. Hilburn, Academic Editor Embry-Riddle Aeronautical
University

David Carter, Corporate/Government Editor Independent
Consultant

Donald J. Bagert, P.E., Professional Issues Editor Texas Tech
University

Laurie Werth, Advisory Committee Member The University of Texas
at Austin

Nancy Mead, Advisory Committee Member Software Engineering
Institute
Datrix
™
source code model and its interchange format
Authors: Lapierre Sébastien , Laguë Bruno , Leduc Charles
Published: July 2004

The Datrix team within Bell Canada has been offering its source code analysis tools to the research community for a number of years. These tools perform a number of analyses that revolve around a central model (
Datrix-ASG
) developed by the Datrix team, and use an interchange format similar to
TA,
which we call
Datrix-TA.
This paper intends to communicate the modeling choices that were made when creating this information model, and the lessons learned over a few years of usage.
COTS workshop
Authors: Dean John , Oberndorf Patricia , Vigder Mark , Abts Chris , Erdogmus Hakan , Maiden Neil , Looney Michael , Heineman George , Guntersdorfer Michael
Published: July 2004

In early June of 2000 a COTS Workshop entitled "Continuing
Collaborations for Successful COTS Development" was held in
Limerick, Ireland in conjunction with ICSE 2000. The purpose of the
workshop was to collect experience reports regarding the use of
commercial off-the-shelf (COTS) software to build systems, identify
best-practices for the use of COTS software, and to establish a
research agenda for those researchers interested in COTS-based
software systems. This one and a half day workshop was an extension
of the work begun during the workshop entitled "Ensuring Successful
COTS Development" held in conjunction with ICSE '99. Results from
that workshop demonstrated that there were a number of common
research areas, including acquisition, planning and management,
architecture and implementation, and evaluation and testing, for
which researchers saw the possibility of collaboration. These areas
included specific topics such as estimating the effort required to
implement COTS-based systems, classification of architectural
styles, and certification of COTS products for reliability and
safety. The group will reconvene at ICSE'01
(www.csr.uvic.ca/icse2001) to discuss further the results
achieved.The ICSE 2000 Workshop had about 26 participants and was
formatted as a combination of plenary sessions and small breakout
groups that worked on specific issues related to COTS-based
systems. The breakout groups investigated the impact of COTS
software usage in the following areas:

Economic and financial issues.

Requirements definition

Software engineering process.

Integration, maintenance and system management.

Business models.

Each breakout group tried to identify the current state of the art
in COTS software usage as well as open questions that could provide
the basis for further research in the coming years. Each group was
responsible for producing a written summary of their discussions
which are included, without major editing, below. A more complete
description of the workshop, as well as all the participants'
position papers, can be found
at:http://seg.iit.nrc.ca/projects/cots/icse2000wkshp/index.html
Design, specification, and verification of interactive systems
Authors: Palanque Philippe , Paternò Fabio
Published: July 2004

More and more software applications are being developed to allow users to access data and communicate information. The parts of such applications dedicated to supporting user interactions is increasingly important and requires novel methods and techniques to develop effective user interfaces. DSV-IS'2000 provided experts from many countries of the world with the unique opportunity to meet and discuss the current state of art and new research results in this area.
Summary of the second ICSE workshop on web engineering
Authors: Deshpande Yogesh , Murugesan San
Published: July 2004

The series of workshops on Web Engineering started in 1998 with the World Wide Web Conference WWW7 in Brisbane, Australia, and has continued with WWW8 (Toronto, 1999) and WWW9 (Amsterdam, 2000). The first such workshop with the International Conference on Software Engineering (ICSE) took place in 1999 in Los Angeles. The second workshop was held on 4-5 June 2000 in Limerick, Ireland and attracted about 30 participants.The main purpose behind these workshops is to share and pool the collective experience of people, both academics and practitioners, who are actively working on Web-based systems.This workshop consisted of two keynote addresses, 11 contributed papers and two sessions of open discussions. The call for papers elicited 18 submissions of which 11 were accepted after peer reviews. The papers presented at the workshop appear in the book
Web Engineering
(San Murugesan and Yogesh Deshpande (eds.), LNCS, Springer-Verlag, 2000).
Workshop on multi-dimensional separation of concerns in software engineering
Authors: Tarr Peri , Harrison William , Ossher Harold , Finkelsteiin Anthony , Nuseibeh Bashar , Perry Dewayne
Published: July 2004

Separation of concerns has been central to software engineering for decades, yet its many advantages are still not fully realized. A key reason is that traditional modularization mechanisms do not allow simultaneous decomposition according to multiple kinds of (overlapping and interacting) concerns. This workshop was intended to bring together researchers working on more advanced modularization mechanisms, and practitioners who have experienced the need for them, as a step towards a common understanding of the issues, problems and research challenges.
Definitions and demographics
Authors: Raccoon L. B. S.
Published: July 2004

Who are software engineers? Answering this question properly, by defining the profession clearly and counting practitioners accurately, will help all software engineers. Practitioners will better understand the career paths that are available. Managers will better understand the jobs that employees fill. Researchers will better predict how the field will evolve. The software engineering community will better understand its identity and will better wield its influence. And, everyone will be able to make more responsible distinctions between who is and is not a software engineer.In the first section, I propose a definition of software engineers as those who focus primarily on software development and who have some depth and breadth of experience in the process, and I propose a scaling model of software engineering demographics. In the second section, I discuss the difficulty of distinguishing between software engineers and non-engineers. I believe that credentials will evolve to help clarify this distinction. And in the third section, I call for a new demographic study tailored to the needs of software engineers. This study should create a complete portrait of the field.I also respond to several criticisms of A Whole New Kind of Engineering: I explain why I believe that in 1998, about 1,000,000 software engineers existed in the U.S. and why software engineers do not need computer science or even technical degrees to prove themselves today, though this will surely change in the future.
Applying software engineering methods for hypermedia systems
Authors: Aedo Ignacio , Díaz Paloma
Published: July 2004

Despite the existence of software engineering methods for hypermedia development, this process is not as systematic as it could be expected and, in fact, the "hypermedia software crisis" still remains. This situation can be attributed to the scarce dissemination of methods for hypermedia. In this context, we present our experience teaching a software engineering method for hypermedia, called Ariadne, which is used to develop hypermedia applications following a user-centered approach.
Problems in comprehending recursion and suggested solutions
Authors: Sooriamurthi Raja
Published: July 2004

Recursion is a very powerful and useful problem solving strategy. But, along with pointers and dynamic data structures, many beginning programmers consider recursion to be a difficult concept to master. This paper reports on a study of upper-division undergraduate students on their difficulty in comprehending the ideas behind recursion. Three issues emerged as the points of difficulty for the students: (1) insufficient exposure to declarative thinking in a programming context (2) inadequate appreciation of the concept of functional abstraction (3) lack of a proper methodology to express a recursive solution. The paper concludes with a discussion of our approach to teaching recursion, which addresses these issues. Classroom experience indicates this approach effectively aids students' comprehension of recursion.
Guidelines for teaching object orientation with Java
Authors: Kölling Michael , Rosenberg John
Published: July 2004

How to best teach object orientation to first year students is currently a topic of much debate. One of the tools suggested to aid in this task is BlueJ, an integrated development environment specifically designed for teaching. BlueJ supports a unique style of introduction of OO concepts. In this paper we discuss a set of problems with OO teaching, present some guidelines for better course design and show how BlueJ can be used to make significant improvements to introductory OO courses. We end by presenting a description of a possible project sequence using this teaching approach.
Towards an error free plagarism detection process
Authors: Lancaster Thomas , Culwin Fintan
Published: July 2004

For decades many computing departments have deployed systems for the detection of plagiarised student source code submissions. Automated systems to detect free-text student plagiarism are just becoming available and the experience of computing educators is valuable for their successful deployment.This paper describes a Four-Stage Plagiarism Detection Process that attempts to ensure no suspicious similarity is missed and that no student is unfairly accused of plagiarism. Required characteristics of an effective similarity detection engine are proposed and an investigation of a simple engine is described. An innovative prototype tool designed to decrease the workload of tutors investigating undue similarity is also presented.
Using personality inventories to help form teams for software engineering class projects
Authors: Rutherfoord Rebecca H.
Published: July 2004

As faculty create their teams for software engineering class projects various techniques may be used to create these teams. Random selection as well as structured assignments all have varied strengths and weaknesses. One method for selecting students involves using personality inventories to assess the various personality types of the students. This paper will discuss how the author used the Keirsey Temperament Sorter to select teams for a software engineering class and some of the results of this experiment.