bluuebunny/crossref_metadata_2025 huggingface dataset:
Flow equations as a generic programming tool for manipulation of attributed graphs
Authors: Fiskio-Lasseter John , Young Michal
Published: July 2004

The past three decades have seen the creation of several tools that extract, visualize, and manipulate graph-structured representations of program information. To facilitate interconnection and exchange of information between these tools, and to support the prototyping and development of new tools, it is desirable to have some generic support for the specification of graph transformations and exchanges between them.G
en
S
et
is a generic programmable tool for transformation of graph-structured data. The implementation of the G
en
S
et
system and the programming paradigm of its language are both based on the view of a directed graph as a binary relation. Rather than use traditional relational algebra to specify transformations, however, we opt instead for the more expressive class of flow equations. Flow equations---or, more generally, systems of simultaneous fixpoint equations---have seen fruitful applications in several areas, including data and control flow analysis, formal verification, and logic programming. In G
en
S
et
, they provide the fundamental construct for the programmer to use in defining new transformations.
The code of many colors
Authors: Sutherland Dean F. , Greenhouse Aaron , Scherlis William L.
Published: July 2004

We introduce a thread colors model as a way to express design intent concerning the relationships between threads, executable code, and shared state. By expressing the model as annotations in code, it is possible to formally link the model with source code and to analyze the consistency of model and code in a composable manner. By using annotations as cut-points, APIs can be annotated and compliance with library threading policies can be evaluated. This is illustrated using case study examples from published code that show how thread coloring models can assist in assuring policy compliance and in identifying concurrency errors.
Can C# replace java in CS1 and CS2?
Authors: Reges Stuart
Published: July 2004

Microsoft has developed a language called C# ("see sharp") that it claims will allow programmers to "quickly and easily build solutions" for its new.NET platform [3]. The language has much in common with Java, particularly in those features emphasized in CS1 and CS2 courses. It also includes some of the desirable features of C++ that are missing from Java as well as some new features not available in either language. This paper explores the pros and cons of teaching CS1 and CS2 using C# instead of Java and concludes with a discussion of the author's plans for teaching such a course in the fall of 2002.
Learning to support the instructor
Authors: VanDeGrift Tammy , Anderson Richard J.
Published: July 2004

In this paper we describe and evaluate Classroom Assessment Tools (CATs) designed to encourage interaction and student ownership in an introductory programming course (CS 1). Traditionally, Classroom Assessment Techniques allow instructors to collect feedback from students regarding their understanding of course material \citeangelo93. We developed and categorized over 60 specific CATs to facilitate discussion and learning in a CS 1 course.The Classroom Assessment Tools described in this paper highlight concepts from recorded lectures that are used in CS 1 distance courses employing the Tutored Video Instruction (TVI) model. We present a qualitative evaluation of Classroom Assessment Tools as discussion frameworks in a TVI course offering. Evidence from site observations, interviews with the instructor and students, and survey responses from the instructor and students indicate that the CATs created classroom interaction, improved students' attitudes in the course, and provided assessment opportunities for the instructor.
Electronic books for programming education
Authors: Martínez-Unanue R. , Paredes-Velasco M. , Pareja-Flores C. , Urquiza-Fuentes J. , Velázquez-Iturbide J. Á.
Published: July 2004

Programming is a suitable field to design electronic books with a laboratory component, where the programming task is exercised in the theoretical context provided by the book. The goal of the paper is to make a review of current electronic books for programming education and identify future lines of research. First, we review a number of software tools and electronic books for programming education in order to give a broad vision of technological opportunities in programming education. Later, a comparative analysis of such electronic books is made. Finally, based on this overview and analysis, we identify aspects that either are currently poorly supported or are a subject of active research, thus constituting potential areas for future improvement.
A dialog between authors and teachers
Authors: Dale Nell , Bishop Judith , Barnes David J. , Kessler Christoph
Published: July 2004

The goal of this panel is to examine the following questions with the audience:

What do you as adopters want from us as authors?

Is there a need to rethink the length of modern textbooks?

Is there a consensus among adopters?

We are a panel of textbook authors from three corners of the universe (actually three continents): South Africa, the United States of America, Sweden, and England. We each have questions for you, our adopters (customers) from all points of the globe.
Experience with a computer-assisted formal programming examination
Authors: English John
Published: July 2004

This paper describes a web-based system for the online delivery of formal examinations and their automated marking. This system was first used in June 2001 in an end-of-year exam for a first year undergraduate programming course. The outcome of this experiment is also described.
Experiences in automatic assessment on mass courses and issues for designing virtual courses
Authors: Malmi Lauri , Korhonen Ari , Saikkonen Riku
Published: July 2004

In this paper, we present some experiences on using automatic assessment in large scale courses of introductory programming, data structures, and algorithms over a period of 10 years. Automatic assessment provides an effective method for giving immediate 24/7 feedback service for students of mass courses. A very important factor in the promoting of learning is the possibility to resubmit answers after receiving the feedback. However, our experience shows that the resubmission option is not the only key motivation factor. More important factors include the challenge of exercises and the grading scale or the course assignments. A successful combination of all of these can produce good learning results.
A multi-agent platform for automatic assignment management
Authors: Pardo Abelardo
Published: July 2004

Automatic assessment has become an important technique to reduce the grading load on teaching staff while providing an exhaustive evaluation environment for students. Several systems have evolved over the years providing sophisticated evaluation capabilities. However, fully automated assessment covers only a portion of the overall evaluation requirements in a typical Computer Science course. In this paper we present a tool for automatic assignment management that aims at satisfying several objectives. First, to support the large variety of assignment types and grading policies under the same paradigm by means of a phgeneric architecture. Second, to provide a phmulti-agent, scalable platform to cope with large enrollment classes. And third, to provide phfull connectivity with other administrative tools already present in educational institutions.
Objects from the beginning - with GUIs
Authors: Proulx Viera K. , Raab Jeff , Rasala Richard
Published: July 2004

We describe a way to introduce objects at the beginning of the first CS course through the use of objects that have significant nontrivial behavior and interactions with other objects. We will describe four introductory laboratory projects and an outline for introductory lectures on object oriented programming that illustrate the need for private member data, constructors and accessor member functions, and prepare students for writing object oriented programs in Java with graphical user interfaces.
Frameworks in CS1
Authors: Christensen Henrik Bærbak , Caspersen Michael E.
Published: July 2004

In this paper we argue that introducing object-oriented frameworks as subject already in the CS1 curriculum is important if we are to train the programmers of tomorrow to become just as much software reusers as software producers. We present a simple, graphical, framework that we have successfully used to introduce the principles of object-oriented frameworks to students at the introductory programming level. Our framework, while simple, introduces central abstractions such as inversion of control, event-driven programming, and variability points/hot-spots. This has provided a good starting point for introducing graphical user interface frameworks such as Java Swing and AWT as the students are not overwhelmed by all the details of such frameworks right away but given a conceptual road-map and practical experience that allow them to cope with the complexity.
Shared terminology, private syntax
Authors: Levy Dalit , Lapidot Tami
Published: July 2004

This paper reports a study in which 11th grade students were observed, while engaged in several learning activities that address general aspects of recursion. One of these learning activities focused on the creation of recursive descriptions using natural language. The class discourse was recorded and analyzed, in order to locate patterns of students' expressions and ways of thinking. The present finding is two-fold. On the one hand, a class genre was created and used to refer to recursive phenomena and to describe them verbally. On the other hand, although they used a shared set of some agreed-upon terms, the students tended to individually construct their unique recursive descriptions. These individual methods of assembly are labeled hereafter as "private syntax". It is concluded that learners' and educators' awareness of both the "building blocks" of any recursive description and the several possibilities for assembling these blocks, might help in the process of understanding recursion in general and in further construction of recursive functions in particular.
Does it make a difference if students exercise on the web or in the classroom?
Authors: Korhonen Ari , Malmi Lauri , Myllyselkä Pertti , Scheinin Patrik
Published: July 2004

Several Web-based learning environments which can automatically give immediate feedback to the students have been reported within the past few years. The quality of feedback can be relatively high in these systems, but it does not achieve the level a trained teacher can provide. However, the lack of the best possible feedback can be compensated for, to some extent, by providing immediate and individualised feedback at any place or time. The question is whether the systems providing automatic feedback are good enough to compete with humans.This paper reports on a randomised large scale intervention study. We found that there was no significant difference in the final examination results between students doing instructed simulation exercises in a classroom session and students using a web-based learning environment, if the exercises were the same. However, with more challenging exercises, there was a significant difference in the examination results, while the drop out rate was higher. Thus, the chosen teaching method and medium did not effect the level of learning, but the quality of the exercises did.
Evaluating the use of a virtual learning environment for teaching aspects of HCI
Authors: Chalk Peter D.
Published: July 2004

In this paper, we describe the results of evaluating a taught module in Human-Computer Interaction (HCI). The focus of this paper is on the use of a virtual learning environment (VLE) - in the case WebCT - as a vehicle for both the taught content and assessment and for demonstrating important aspects of HCI. Evidence of student learning is presented and evaluated, including examples of work submitted through the VL, and the results of an evaluation questionnaire.
Undergraduate research experience in computer science education
Authors: Greening Tony , Kay Judy
Published: July 2004

Computer Science Education is gradually emerging as a valid research focus within the wider computer science community. This paper presents an account of a successful subject that offers senior undergraduates experience of research using Computer Science Education as the focus. The paper is not itself a research paper, but advocates a role for CS Ed as an undergraduate research focus and offers a case study of a successful implementation of such a programme.
Reducing abstraction level when learning computability theory concepts
Authors: Hazzan Orit
Published: July 2004

The paper illustrates how theories from mathematics education can be applied for explaining student conception of computing science ideas. It does this by demonstrating how the theme of reducing abstraction [5] can be used for analyzing students' mental processes when the students are in the process of solving problems in Computability Theory. The topic of Computability Theory in presented here as an example for demonstrating how research in Computing Science education can use learning theories, "borrowed" from mathematics education research, for explaining learning processes.
Specific proposals for the use of petri nets in a concurrent programming course
Authors: Barros João Paulo
Published: July 2004

Concurrency is a difficult subject to teach and learn. This paper presents a set of recipes for the use of Petri nets as a teaching aid of some fundamental concurrency concepts, in the context of an introductory concurrent programming course. Classroom experience clearly demonstrates this usage of Petri nets improves students understanding of concurrency concepts.
A state of the course report
Authors: Cassel Lillian (Boots) , Kumar Deepak
Published: July 2004

We present a "state of the course" report on a core computer science topic: Computer Organization & Architecture. Our report is based on a survey of over 80 faculty, at colleges and universities around the world, who teach this topic. Based on the responses in the survey, we present our conclusions on the confidence levels of faculty in teaching various core components of the topic. We will present our results in the context of the identified core body of knowledge as defined in the Curriculum 2001. These conclusions can be of help to experts who are willing to provide training and/or pedagogical materials in order to assist those with low confidence levels.
Cheating and plagiarism
Authors: Sheard Judy , Dick Martin , Markham Selby , Macdonald Ian , Walsh Meaghan
Published: July 2004

A study of cheating and plagiarism using a scenario based format, has provided an insight into attitudes towards questionable work practices of first year information technology students' within the School of Computer Science and Software Engineering of Monash University, and the School of Information Technology of Swinburne University. Students at both institutions showed similar responses to a range of cheating behaviours, in line with other literature. Plagiarism and cheating are widely tolerated and commonly practised, at least on the lower end of the spectrum of seriousness. However there were some areas of significant difference between the two student samples that warrant further research to develop strategic approaches for limiting cheating practices.
Gender differences in programming?
Authors: Carter Janet , Jenkins Tony
Published: July 2004

This paper presents the findings of an interactive poster of the same name that was displayed at two Computer Science Education conferences during the summer of 2001. Delegates were presented with fragments of code written by first year Computer Science undergraduates and were asked to determine whether the code authors were male or female. The findings suggest that not only is it not possible to determine the gender of the author, but that the gender stereotyped 'clues' relied upon as a basis for the determination are unreliable predictors.
Import and export to/from computing science education
Authors: Almstrum Vicki L. , Ginat David , Hazzan Orit , Morley Tom
Published: July 2004

This panel will look at how research theories developed in the context of mathematics education can be applied to computing science education as well as ways in which computing science theories may be used in mathematics education research. Computing science education is a young discipline still in search of its research framework [6]. A practical approach to formulating such a framework is to adapt useful approaches found in the research from other disciplines, both educational and related areas. At the same time, a young discipline may also offer innovative new approaches to the older discipline.The mathematics education discipline is relatively mature, with its roots extending from the close of the 19th century. For about the past 50 years, mathematics educators have been studying learning theories, teaching approaches, and other cognitive and social issues with respect to K-12 and higher education. We have found that many of these theories are useful for gaining insights into how students learn and understand computing science topics, as well as for improving how we teach these topics. For example, the constructivist perspective, which examines students' mental construction of knowledge [7], has had a tremendous impact on the teaching of mathematics. This paradigm, with its roots in Piaget's work, has started to exert a similar influence within computing science education, as evidenced by a recent article by Ben-Ari [4] and a subsequent special issue of
Computer Science Education
[10] that includes six articles about constructivism in various areas of computing.Another branch of mathematics education research theory focuses on student conceptions of specific mathematical concepts. For example, student understanding of the concept of function has been researched extensively in the mathematics education context [8]. This cumulative body of knowledge provides a basis for analyzing students' conceptions in many areas of a computing science program, including functional programming, object-oriented programming, and graph algorithms.The panelists will examine possibilities and pitfalls in some import and export attempts between mathematics education research and CS education research.
Teaching on the wiki web
Authors: Bergin Joseph
Published: July 2004

A wiki is a completely interactive web site. Any page can be edited by any visitor. It is driven by a specialized web server or set of cgi scripts generating dynamic pages from the results of visitor edits. A visitor edits a page by grabbing the current content of a page in an ordinary web form and editing it arbitrarily and then saving it back. Users can also create new pages. Generally the name of a page is the name of a topic. Most wikis are text only. The syntax of a wiki is simpler than HTML, but HTML is recognized by some wikis. Some wikis are very easy to administer. There is no history or automatic backup, however. A wiki is totally "live.
Very active learning of network routing
Authors: Cassel Lillian N.
Published: July 2004

Active learning promises students will really own what they have learned because they have done something rather than only read or listen. The following classroom exercise has been used at both the undergraduate and graduate level Computer Networks courses. There has been no formal study of its effectiveness, but an informal result is telling: Two routing algorithms presented in class. On an exam, students are asked to choose one of them and describe it. In several years of using this classroom exercise, nearly all the students chose the method we did with this exercise and they all explained the algorithm correctly.
A diagnostic technique for addressing group performance in capstone projects
Authors: Clear Tony
Published: July 2004

"Students' awareness of their own group processes can be poor (or Absent)" [1]. Yet professional software development situates much work within groups, and capstone courses are often designed to develop capabilities, such as effective teamwork. Supervising group processes can be challenging, and encouraging students to reflect upon group functioning can be a delicate exercise. A technique is outlined below, for group performance review and diagnosis of issues preventing teams functioning effectively.
A musical approach to teaching design patterns
Authors: Hamer John
Published: July 2004

In case you missed the signs, design patterns [2] have suddenly become a core programming topic. The Computing Curricula 2001 [1] includes the topic as a major part of SE1 "software design," and in a recent survey [4] software practitioners ranked "software design and patterns" as one of the areas of knowledge they consider most important to their work.Teaching design patterns, however, is not so easy. Patterns need to be studied in the context of a software design project; to do otherwise renders the topic asomatous. We have met with some success in using "musical composition" to teach a number of standard design patterns, including Composite, Decorator, Visitor, and Factory. The idea of musical composition comes from Paul Hudak's Haskore system [3].The project centers on the design of a "musical object," by which we mean either a note (with a pitch and duration), a rest (having just a duration), or a combination of musical objects. The combinations can be contemporaneous (as for a chord), or sequential (like a scale). The two primitive music types together with the combinators come together using the Composite inheritance pattern. Decorators can then be added to describe tempo changes (the scaling of the duration of all parts of a musical object), pitch transpositions, and to assign different instruments to parts of a composition.With the descriptive part of the system so formed, a Visitor can be used to traverse the musical tree and generate a linear sequence of "musical events," which can then be written as type 1 MIDI files for playback on most standard PC equipment. As well as learning about design patterns, students are given the opportunity to try their hand at transcription or composition. Some examples of their work can be found at http://www.cs.auckland.ac.nz/courses/ compsci360fc/ archive/1999/Ass2/PickOfTheBest/.
Evaluating student team project experiences
Authors: Laxer Cary
Published: July 2004

The first two courses in the computer science major at Rose-Hulman (Algorithm & Program Design and Data Structures) each have a five-week team-programming project as a component of the course. At the end of the projects, in addition to their program code, each team has to submit a user's manual and a technical manual for their product, and give a 15-20 minute oral presentation. The students are also required to evaluate the project experience on an individual basis.To facilitate the project evaluation, I designed three forms. One form is given to each team leader to complete, one form is given to the other team members, and the third form is used by me to evaluate (i.e., grade) the project. The general team member evaluation form asks the student if, in the student's opinion, everyone contributed his or her fair share to the project, how they viewed their time commitment to the project, what the strengths and weaknesses of their team leader were, to summarize the team dynamics on the project, and to comment on how worthwhile the project was. The evaluation form the team leaders complete asks them about the contributions of their team members; recommendations for "pay raises," "promotions," and "dismissals;" team dynamics; their strengths and weaknesses as team leaders; and how worthwhile the project was. The form I use to evaluate the projects has areas for me to comment on their oral presentation, the software quality, the program design, and the documentation, as well as provide a numeric grade in each area.
Group work at postgraduate level
Authors: Joyce Donald
Published: July 2004

This paper reviews the experience with group assignments during the first five semesters that UNITEC's Master of Computing programme has been offered. Strategies for forming and managing groups are outlined, as well as different approaches to awarding grades to the individual members of the groups.
MISC
Authors: Scott Kirk
Published: July 2004

The minimal instruction set computer (MISC) is a simulation of a simple hardware machine written in the Java language. The architecture represented is register-oriented. MISC has been used by the author in several classes at the undergraduate level. It is under further development at the present time.
CITIDEL
Authors: Knox Deborah
Published: July 2004

In this demonstration, we present the features of the Computing and Information Technology Interactive Digital Educational Library project (CITIDEL). CITIDEL is being developed to bring learning resources related to computing into one open archive and search center. We will demonstrate the current status of development of CITIDEL, both in terms of collections accessible and of technical developments for data provision and harvesting. (www.citidel.org http://www.citidel.org).The CITIDEL development team includes people from Virginia Tech (the lead institution), Hofstra University, Penn State University, The College of New Jersey, and Villanova University. CITIDEL is part of the Collections Track activities in the U.S. National STEM (Science, Technology, Engineering, and Mathematics) education Digital Library (NSDL, www.nsdl.nsf.gov). Our focus includes technical development, content collection, search engine technology, assessment, and community development.Topics presented include metadata harvesting of collections, tailored search capabilities, and a demonstration of the front-end access to the educational resources related to computing and information technology. Conference attendees interested in having their work accessible through CITIDEL will have the opportunity to talk with a project representative during the demonstration time. Avenues of dissemination include the ACM Journal of Educational Resources in Computing (JERIC) and the Computer Science Teaching Center (CSTC, www.cstc.org).
Integrating formal methods tools into undergraduate computer science curriculum
Authors: Skevoulis Sotiris , Falidas Maria
Published: July 2004

In this paper we describe a recently NSF-funded project that is based on the power of an innovative teaching approach, which combines the traditional teaching models and adds the use of automated software tools to enhance the student's learning experience.
Conferencing technologies and online courses
Authors: Shukla Ranjana , Joyce Donald
Published: July 2004

This poster evaluates four conferencing technologies from the perspective of enhancing the delivery of online courses, in particular by incorporating real time discussions, presentations or seminars. The analysis can be used when choosing the most appropriate technology for a specific context.
Web-based systems for supporting computer-science teaching and learning
Authors: Kasyanov Victor N. , Kasianova Elena V.
Published: July 2004

The systems PRACTICE and GRAPP being under development at the A. P. Ershov Institute of Informatics Systems in Novosibirsk are considered. They are Web-based systems intended to support computer-science teaching and learning. In the paper the current versions of systems being in use by students of Novosibirsk State University are presented, and our plans are outlined.
Learning how to develop software using the toy LEGO mindstorms
Authors: Garcia Mario A , Mc-Neill Holly Patterson
Published: July 2004

The use of the toy LEGO Mindstorms has been used more often in Engineering and Computer Sciences courses in several countries. Undergraduate students at Texas A&M University-Corpus Christi implemented seven robotics applications as the final project for the Software Analysis and Design course. The students applied the knowledge acquired in other courses such as Software Engineering, Databases, and several programming courses. The students used Microsoft project for the planning phase and the CASE tool Visible Analyst for the design phase. At the end of the semester there was a robot competition. Two projects are described in this paper.
DoIT
Authors: Ramakrishnan Sita
Published: July 2004

This paper describes our innovative web based system, DoIT. DoIT is an acronym for Dynamic Curriculum Organisation by Innovation through Technology. IEEE-CS and ACM have been working on developing a comprehensive body of knowledge on software engineering (SWEBOK) [1]. Carnegie-Mellon Software Engineering Institute [CMU/SEI-99-TR-032] has produced a document that presents some guidelines for using the SWEBOK to support effective curriculum design. Our DoIT project has used the SWEBOK classification to map the core units in our current BSE curriculum against the SWEBOK knowledge key areas. In many engineering disciplines, the accreditation of university curricula and the licensing and certification of practicing professionals are taken very seriously. These are seen as critical to ensure upgrading of course content and structure where warranted to achieve improvements in the level of professional practice. Recognition of the core body of knowledge in a discipline is crucial to the development and accreditation of university curricula. DoIT system has been engineered in a systematic and disciplined manner and allows our Bachelor of Software Engineering students at Monash University to view the key areas of software engineering body of knowledge (SWEBOK) that they learn in their core subjects of study as they progress through our course. The main objective of the system is to provide an Internet facility for the students to learn about what they have learnt in their subjects in terms of SWEBOK objectives. The main inputs to DoIT are the SWEBOK key areas, our BSE core subjects mapped to SWEBOK and BSE student information extracted from Monash' student ORACLE database at the beginning of each new semester of our BSE course. Our BSE students are able to interact with the DoIT system to retrieve a personalized competency profile (PCP) at the completion of each semester of study. The contents visualized through the web site DoIT evolves as the students move through the course and works with up to date information about students. The web-based system, DoIT can be viewed at http://www.csse.monash.edu.au/~doit/. The learning outcomes from DoIT can be considered from three perspectives [2]. It is about:

Students' learning about what they have learnt in terms of course content shown as knowledge areas covered in SWEBOK objectives.

Lecturing staff and curriculum designers able to track the curriculum and see how the various topics relate together, and ascertain if there are any overlaps and gaps in knowledge.

The educational institution able to see the organisational knowledge assets in terms of graduate capabilities from our course.
Guidelines for associate-degree programs in computer science
Authors: Klee Karl J.
Published: July 2004

This poster presentation showcases the recently published ACM/IEEE-CS guidelines for computer science programs at associate-degree granting institutions. These guidelines were produced by the Two-Year College Education Committee, a standing committee of the ACM Education Board. Karl Klee is one of the Committee members.
Virtual Interface Machine
Authors: Han Hong , Lu Jun , Lu Xianliang
Published: July 2004

In this paper, we try to tackle three relative problems in software design. The first one is the separation of user interface (UI) from logic layer. The second one is the decoupling of components of UI. The last one is how to combine high reusability design with efficiency of drag-and-drop mode of rapid application development (RAD) tools. As far as decoupling is concerned, there are many design patterns to tackle it, such as MVC (Model-View-Controller), Mediator, Observer, Visual Proxy, etc, which are not satisfying, because of the obvious disadvantage that collaborative components are actually tightly coupled by a specific object (like mediator, controller, etc). As for the last problem, many hold that drag-and-drop mode of RAD would compromise the reusability and maintainability of OO design. We use a method called drag-drop-and-add to achieve both reusability and efficiency. This paper presents a pattern called Virtual Interface Machine that let us separate UI from logic layer, decouple components of UI entirely and enjoy efficiency of RAD in UI design without compromising reusability and maintainability of the whole design. By the thorough decoupling, we could even change both logic layer and UI at run time, which is impossible to other patterns. In practice, we implemented the pattern in our Intrusion Detection System (IDS).
The SALADIN project
Authors: Inverardi Paola
Published: July 2004

It is apparent that, in the near future, software production will be more and more involved with applications running on heterogeneous networks, often with mobile components. Witness the increasing availability of reliable broadband communication networks, which span local, metropolitan and worldwide areas, and the high popularity of newly conceived applications on Internet, such as the World Wide Web. The development of applications for heterogeneous distributed networks that support mobile components (in short, programming mobile agents) demands innovative design and programming techniques. In this report we summarize the activities and results achieved in the SALADIN project, an Italian National project funded by the Italian Ministry of University and Research. We consider our experience interesting for the Software Engineering community because it has been a successful experiment in putting together teams whose expertise was sensibly different and complementary. This has allowed us to exploit the cooperation of different complementary competencies that are needed to reach significant results in an area where methods and tools, which are specific of several area of computing come naturally together.
Value-based software engineering
Authors: Boehm Barry
Published: July 2004

The Value-Based Software Engineering (VBSE) agenda described in the preceding article has the objectives of integrating value considerations into current and emerging software engineering principles and practices, and of developing an overall framework in which they compatibly reinforce each other. In this paper, we provide a case study illustrating some of the key VBSE practices, and focusing on a particular anomaly in the monitoring and control area: the "Earned Value Management System." This is a most useful technique for monitoring and controlling the cost, schedule, and progress of a complex project. But it has absolutely nothing to say about the stakeholder value of the system being developed. The paper introduces an example order-processing software project, and shows how the use of Benefits Realization Analysis, stake-holder value proposition elicitation and reconciliation, and business case analysis provides a framework for stakeholder-earned-value monitoring and control.
Software development
Authors: Buhrer Hans Konrad
Published: July 2004

Developing large software systems is notoriously difficult and unpredictable. Software projects are often canceled, finish late and over budget, or yield low quality results --- setting software engineering apart from established engineering disciplines. While puzzling at first glance, the shortcomings of software "engineering" can easily be explained by the fact that software development is a craft and not an engineering discipline. To become an engineering discipline, software development must undergo a paradigm shift, away from trial and error towards a scientific theory of software.
Testing with hostile data streams
Authors: Jorgensen Alan A.
Published: July 2004

This note describes a method of testing software for response to malicious data streams. Systems that process data streams obtained from an external source such as the Internet are vulnerable to security issues if malicious data is not processed correctly. This note describes a testing method that creates malicious data streams, applies them to a software application and checks the appropriateness of the application response.The note begins with a description of the problem: inade-quate testing of software response to malicious data streams. I present a method of testing the response to malicious data streams and introduce the concepts of lexical, syntactic and semantic data stream deformation. I provide a description of a system that produces and applies such tests. This descrip-tion divides the testing system into components and provides some detail about each component. This system applied to Adobe Acrobat Reader version 5.0.1 provides a case study. The study applied 141,306 unique test cases and revealed 11 distinct indications of buffer overrun, numerous program lock-ups, and four steganographic possibilities.Research is on-going in the following areas: generalized buffer overrun exploitation, maliciously testing protocols and testing with encoded or encrypted data streams.
An adaptive dependability model of component-based software
Authors: Lin Mei , Yongsen Xu
Published: July 2004

With the advancement and widespread use of object-oriented system design and web-based development, the use of CBSD (Component-Based Software Development) is on the rise. Software systems are being developed in a heterogeneous fashion using components developed in-house, or picked off-the-shelf, and hence it may be inappropriate to model and evaluate such systems on using traditional tools. We proposed an integrated and adaptive approach, which takes into account the diversity of dependability requirements, to model the dependability, the most important aspect of evaluation, of a heterogeneous software system based on its architecture and the failure behavior of its components. The basic constituent of our approach is BBNs (Bayesian Belief Networks), which are by far the best model that can handle integration of variables of process and product, relationships of genuine cause and effect, and other uncertain information.
Object database support for a software project management environment
Authors: Liu Lung-Chun , Horowitz Ellis
Published: July 2004

The recent development of object-oriented database models, which combine the power of object programming and the efficient management of data, provides a feasible solution for the construction of a computer-aided software engineering environment or CASE. However, an object oriented database provides only a kernel set of capabilities. This paper identifies the data management requirements related to software project management and shows how they are represented in the model called Design-Net. Then it is shown how the concepts of the work breakdown structure, project history, event monitoring, and re-initiation of tasks are realized in a specific object-oriented system. Limitations of existing object oriented database systems are identified, with respect to implementing these concepts. Based upon an actual prototype, recommendations are made for enhancing future object-oriented systems.
An integrated toolset for engineering software configurations
Authors: Mahler Axel , Lampen Andreas
Published: July 2004

Configuration management in toolkit oriented software development environments (SDE), such as the UNIX system, is a long standing nuisance. Mostly, one has to face the choice between poorly or not at all integrated, independent tools, or highly integrated, most specialized, and often language dependent environments. The first choice offers very limited support for a complex task that needs a broad informational basis. The second choice often takes away the programmers' most cherished tools, forces him to adopt some different work discipline, and thereby eventually restricts his creativity. The toolset described in this paper integrates a dedicated version control system and shape, a significantly enhanced Make [Feld79a] program, on the basis of a common object model. This object model comprises multiple versions of software objects as well as conventional file system objects. Taking this approach made it possible to have a sufficiently integrated toolsystem for engineering software configurations while retaining the flexibility of the basic toolbox philosophy, permitting the use of 'off-the-shelf' tools, e.g. editors or compilers.
Centaur: the system
Authors: Borras P. , Clement D. , Despeyroux Th. , Incerpi J. , Kahn G. , Lang B. , Pascual V.
Published: July 2004

This paper describes the organization of the CENTAUR system and its main components. The system is a generic interactive environment. When given the formal specification of a particular programming language-including syntax and semantics — it produces a language specific environment. This resulting environment includes a structure editor, an interpreter/debugger and other tools, all of which have graphic interfaces. CENTAUR is made of three parts: a database component, that provides standardized representation and access to formal objects and their persistent storage; a logical engine that is used to execute formal specifications; an object-oriented man-machine interface that gives easy access to the system's functions. CENTAUR is essentially written in Lisp (Le_Lisp). The logical engine is Prolog (Mu-Prolog). The man-machine interface is built on top of the virtual graphics facility of Le_Lisp, itself primarily implemented on top of X-Windows.
The ergo support system: an integrated set of tools for prototyping integrated environments
Authors: Lee Peter , Pfenning Frank , Rollins Gene , Scherlis William
Published: July 2004

The Ergo Support System (ESS) is an engineering framework for experimentation and prototyping to support the application of formal methods to program development, ranging from program analysis and derivation to proof-theoretic approaches. The ESS is a growing suite of tools that are linked together by means of a set of abstract interfaces. The principal engineering challenge is the design of abstract interfaces that are semantically rich and yet flexible enough to permit experimentation with a wide variety of formally-based program and proof development paradigms and associated languages. As part of the design of ESS, several abstract interface designs have been developed that provide for more effective component integration while preserving flexibility and the potential for scaling. A benefit of the open architecture approach of ESS is the ability to mix formal and informal approaches in the same environment architecture. The ESS has already been applied in a number of formal methods experiments.
The workshop system: a practical knowledge-based software environment
Authors: Clemm Geoffrey M.
Published: July 2004

The Workshop System is a programming environment designed to support teams of programmers working concurrently on large software projects. An essential feature of the Workshop System is the storage of all information from the software project as fine grained objects in a shared database. In order to allow effective usage of this potentially overwhelming amount of information, the Workshop System provides a rule-based language called SE-KRL for specifying both the software objects and the software process for a given domain. SE-KRL programs can then be written to automate mechanical aspects of the software development process as well as to guide the essential creative activity of a software engineer.
A plan-based intelligent assistant that supports the software development
Authors: Huff Karen E. , Lesser Victor R.
Published: July 2004

We describe how an environment can be extended to support the
process
of software development. Our approach is based on the AI
planning
paradigm. Processes are formally defined hierarchically via plan operators, using multiple levels of abstraction.
Plans
are constructed dynamically from the operators; the sequences of actions in plans are tailored to the context of their use, and conflicts among actions are prevented. Monitoring of the development process, to detect and avert process errors, is accomplished by
plan recognition
; this establishes a context in which programmer-selected goals can be automated via
plan generation
. We also show how
nonmonotonic reasoning
can be used to make an independent assessment of the
credibility
of complex process alternatives, and yet accede to the programmer's superior judgment. This extension to intelligent assistance provides deeper understanding of software processes.
The relationship between software development environments and the software process
Authors: Notkin David
Published: July 2004

The program committee originally planned for this panel session (and this introduction) to provide a summary of the 4th International Workshop on the Software Process. I have taken the liberty of covering a slightly more general view of the relationship between software development environments and the software process.
The ergo attribute system
Authors: Nord Robert L. , Pfenning Frank
Published: July 2004

The Ergo Attribute System was designed to satisfy the requirements for attributes in a language-generic program derivation environment. It consists of three components: (1) an abstract data type of attributes that guarantees attribute consistency, (2) a Common Lisp implementation which combines demand-driven and incremental attribute evaluation in a novel way while allowing for attribute persistence over many generations of a program, and (3) an attribute-grammar compiler producing code based on this abstract data type from a high-level specification. Our experience with three major applications (one being the attribute-grammar compiler itself) confirms that the overhead in storing and accessing attributes incurred by our implementation scheme is more than offset by the gains from the demand-driven, incremental, and persistent nature of attribution.
TEAM: a support environment for testing, evaluation, and analysis
Authors: Clarke Lori A. , Richardson Debra J. , Zeil Steven J.
Published: July 2004

Current research indicates that software reliability needs to be achieved through the careful integration of a number of diverse testing and analysis techniques. To address this need, the TEAM environment has been designed to support the integration of and experimentation with an ever growing number of software testing and analysis tools. To achieve this flexibility, we exploit three design principles: component technology so that common underlying functionality is recognized; generic realizations so that these common functions can be instantiated as diversely as possible; and language independence so that tools can work on multiple languages, even allowing some tools to be applicable to different phases of the software lifecycle. The result is an environment that contains building blocks for easily constructing and experimenting with new testing and analysis techniques. Although the first prototype has just recently been implemented, we feel it demonstrates how modularity, genericity, and language independence further extensibility and integration.
Extended programming in the large in a software development environment
Authors: Lewerentz Claus
Published: July 2004

This paper deals with the programming in the large part and the integration with related activities (programming in the small, variant control, support of technical documentation, responsibility and access control) of the software development and maintenance process. It is pointed out how these tasks are supported with an integrated and incremental software project support environment (IPSEN).

Snapshots of a working session are used to demonstrate the user interface and the functionality of the tools for the above mentioned topics. The main concern of this paper is to show how an incremental and integrated tool set, regarding the consistency of software documents can support software development.