bluuebunny/crossref_metadata_2025 huggingface dataset:
Software quality assurance tools
Authors: Fischer Kurt F.
Published: July 2004

The objective of software quality assurance (QA) is to assure sufficient planning, reporting, and control to affect the development of software products which meet their contractual requirements. To implement this objective, eight QA functions can be identified:

1. Initial quality planning

2. Development of software standards and procedures

3. Development of quality assurance tools

4. Conduct of audits and reviews

5. Inspection and surveillance of formal tests

6. Configuration verifications

7. Management of the discrepancy reporting system

8. Retention of QA records

The purpose of this paper is to document experiences gained in the use of selected QA tools that perform some of the above functions, to discuss lessons learned, and to suggest future needs.
A framework for the measurement of software quality
Authors: Cavano Joseph P. , McCall James A.
Published: July 2004

Research in software metrics incorporated in a framework established for software quality measurement can potentially provide significant benefits to software quality assurance programs. The research described has been conducted by General Electric Company for the Air Force Systems Command Rome Air Development Center. The problems encountered defining software quality and the approach taken to establish a framework for the measurement of software quality are described in this paper.
Using performance metrics in system design
Authors: Lockett Joann
Published: July 2004

Complexities of system design are great and often lead designers to be inward looking in their analyses. Knowledge from various fields can be of benefit in designing systems [1]. Management accountants can describe economic effects of delays in closing schedules, psychologist can provide significant insights into the behavioral characteristics of users to complex command syntax, computer performance analysts can provide alternatives to describe and to measure responsiveness of systems. Even in the case of an innovative system design, the designer can employ such approaches to identify incipient problems and create alternatives with increased cost effectiveness. This paper describes how
performance metrics
can be used effectively to support system design.
Responding to MIL-S-52779
Authors: Southworth Richard N.
Published: July 2004

The art and science of computer software development is still changing considerably from year to year, and therefore lacks the established control mechanisms of hardware production programs. Also, because most software is produced in a one-time development program it does not lend itself to the established discrepancy detection and correction techniques used in hardware production programs. Consequently, the software QA program must providethe methodology to detect a deficiency the first time it occurs and effect corrective action.

MIL-S-52779: “Software Quality Assurance Program Requirements,” has provided a much needed impetus for software development contractors to develop software QA techniques. But much remains to be done. As the state of the art advances MIL-S-52779 should be revised accordingly. In this paper the author responds to the present form of the specification, suggests some revisions and additions and briefly discusses a set of QA procedures that should be responsive (fully compliant) with MIL-S-52779.
The importance of explicitly stating educational objectives in computer science curricula
Authors: Clarke Faith , Reichgelt Han
Published: July 2004

Designing an appropriate baccalaureate curriculum is a difficult and challenging process. The process becomes even harder in environments with severe resource limitation, as one is forced to make hard choices about which courses and topics to include in the curriculum. This paper describes the curriculum design efforts made in a small Computer Science Department at the Jamaica campus of the University of the West Indies. The effort started with a formulation of explicit program outcomes, which then guided the curriculum design. The paper also describes the reasons that led the department to embark on this curriculum design process and gives some of the benefits that the Department has seen as a result of its efforts.
Bottom-up education
Authors: Knuth Donald E.
Published: July 2004

People who discover the power and beauty of high-level, abstract ideas often make the mistake of believing that concrete ideas at lower levels are relatively worthless and might as well be forgotten. The speaker will argue that, on the contrary, the best computer scientists are thoroughly grounded in basic concepts of how computers actually work, and indeed that the essence of computer science is an ability to understand many levels of abstraction simultaneously. Therefore he has put considerable effort into the design of a RISC machine called MMIX, as an aid to computer science educators. MMIX is intended to be simple and clean yet realistic. Many tools have been built to simulate the MMIX architecture, and more are under development.
Cognitive and social aspects of software engineering
Authors: Hazzan Orit
Published: July 2004

This article focuses on teaching and learning human aspects of Software Engineering (SE). Based on several classes that the author taught on the subject, the article describes a framework for a course that deals with cognitive and social aspects of SE. In these classes students worked in teams, and the lessons consisted of lectures, activities, class discussions, and student presentations. The activities which students worked on aimed to address two of the human aspects of SE: the cognitive aspect and the social aspect. Each of these aspects was discussed on the individual level and on the team level. The paper describes selected activities taken from these classes.
Introducing unit testing with BlueJ
Authors: Patterson Andrew , Kölling Michael , Rosenberg John
Published: July 2004

The teaching of testing has never been easy. The introduction of object orientation into first year courses has made it even more difficult, since more and smaller units need to be tested more often. In professional contexts this is addressed by the use of testing support software. Unfortunately, no adequate software to support testing for introductory students is widely available, leaving teachers and students of first year courses struggling.In this paper we describe an attempt to address this problem by combining two existing systems that partly address our needs. We describe an integration of JUnit into BlueJ, which creates a testing tool that exhibits the flexibility and ease-of-use of the BlueJ system combined with the structured unit test approach provided by JUnit.
Providing process for projects in capstone courses
Authors: Goold Annegret
Published: July 2004

Our capstone course has undergone a number of evolutionary changes over the past few years. It was restructured to provide more realistic experiential learning with the introduction of larger software development projects involving 'real clients (sponsors)' and larger student teams with a mix of students across disciplines. We have introduced a project management focus into the course that allows for a more structured process of product development. This restructure was possible because the curriculum prior to the project course emphasized teamwork and project management.This paper provides some background about our capstone course and the significance of the contribution made by two other courses taken earlier in the programme.
Measuring effectiveness of constructivist and behaviourist assignments in CS102
Authors: Parker J. R. , Becker Katrin
Published: July 2004

Two approaches to setting programming assignments are compared, using actual assignment and solutions from two distinct CS102 lecture sections during the same semester. The complexity and effort represented by the solutions is compared using software engineering metrics, giving a measure of the effectiveness of the two assignments sets, and student performance in successor courses is also examined.
The evaluation of electronic marking of examinations
Authors: Thomas Pete
Published: July 2004

This paper discusses an approach to the electronic (automatic) marking of examination papers, in particular, the extent to which it is possible to mark a candidate's answers automatically and return, within a very short period of time, a result that would be comparable with a manually produced score. The investigation showed that there are good reasons for manual intervention in a predominantly automatic process. The paper discusses the results of tests of the automatic marking process that in two experiments yielded grades for examination scripts that are comparable with human markers (although the automatic grade tends to be the lower of the two). An analysis of the correlations between the human and automatic markers shows highly significant relationships between the human markers (between 0.91 and 0.95) and a significant relationship between the average human marker score and the electronic score (0.86).
Making connections
Authors: Schwarm Sarah , VanDeGrift Tammy
Published: July 2004

Students bring prior knowledge and experiences to the classroom. According to the constructivist learning theory, students incorporate new knowledge into their existing knowledge frameworks. We used Classroom Assessment Techniques in an information technology course to elicit the construction of knowledge process. We found that CATs and instructor feedback can help shape and reveal this construction process. For example, responses to CATs revealed students' understandings of variables, digital representation, and iteration in the information technology domain. Some students claimed that the CATs helped put new ideas into their own words and helped them simplify the concepts.
The winds of change
Authors: Lynch Kathy , Markham Selby
Published: July 2004

The information technology workforce now more than ever requires graduates to be ready to 'produce' the instant they 'hit the ground'. The core discipline knowledge and skills haven't changed dramatically over the years, but the 'soft skills' have changed and have become more important than ever. Undergraduate information technology degree must prepare graduates for the workforce, and not just transmit the discipline knowledge for them to achieve 'academically'. To ward off this, a change is required in the pedagogy, and consequently the learning environment for information technology students. With this is mind, Monash University introduced a studio model of teaching and learning into its Bachelor of Information Systems degree program. During the three years of the program students are confronted with two very different pedagogical models of teaching and learning. Seventy five percent of the program is taught in a traditional manner, the remaining twenty five percent is taught within a studio context.The first section of the paper briefly outlines a crude description of the traditional learning environment and the studio learning environment underpinning the IT studio-model that is used in the Bachelor of Information Systems at Monash University. The second section of the paper reports on a quantitative research study that examined students' opinions of which type of model (studio or non-studio) best meets their learning needs.
Teaching undergraduate software design in a liberal arts environment using RoboCup
Authors: Huang Timothy , Swenton Frank
Published: July 2004

Most large research universities include a software design or software development course as a required or elective component of an undergraduate computer science major. For various reasons, some institutions, including many liberal arts colleges and primarily undergraduate institutions, do not. In this paper, we present a software design course, tailored to undergraduate computer science students within a liberal arts environment, based on the RoboCup soccer simulation platform. We describe the course curriculum and outline its goals, which student evaluations suggest it achieved. We also outline the features of our "NewKrislet" soccer player, which provides an elementary but sufficiently functional entry point to Robocup client design.
Making program execution comprehensible one level above the machine language
Authors: Yehezkel Cecile
Published: July 2004

The aim of courses in computer organization at the introductory level is not to produce qualified assembly language programmers but rather, to make the program's execution and the interaction with the hardware comprehensible at the lower programming language level (above machine code). We briefly describe an environment developed with this aim. Recent findings on the evaluation of visualization environment suggest that the evaluation should focus on the way students actually use these environments to better reveal the expected outcomes. To clarify this issue, we used an evaluation procedure based on this approach that provides far-reaching conclusions on the impact of the use of the environment on students' understanding of program execution.
Studying program correctness by constructing contracts
Authors: Gegg-Harrison Timothy S. , Bunce Gary R. , Ganetzky Rebecca D. , Olson Christina M. , Wilson Joshua D.
Published: July 2004

Because the concept of program correctness is generally taught as an activity independent of the programming process, most introductory computer science (CS) students perceive it as unnecessary and even irrelevant. The concept of contracts, on the other hand, is generally taught as an integral part of the programming process. As such, most introductory CS students have little difficulty understanding the need to establish contracts via preconditions and postconditions. In order to improve teaching program correctness concepts, we implemented ProVIDE, an enhanced integrated development environment (IDE) for Java [7]. Pro VIDE supports a modified version of the "design by contract" methodology [13] that assists its student programmers in contract construction. Rather than asking for both a precondition and postcondition for each of his/her methods, ProVIDE asks the student to simply supply a postcondition. ProVIDE then helps the student construct the appropriate precondition by leading him/her through an axiomatic proof of the correctness of the method. Thus, the proof of correctness of the method is a side-effect of the student's need to construct an appropriate precondition.
A companion technology approach to CS1
Authors: Allert James
Published: July 2004

All incoming freshmen majoring in computer science at the University of Minnesota Duluth (UMD) are required to purchase a handheld computer with wireless capability (HP/Compaq IPAQ). The integration of these devices into the CSI curriculum was primarily achieved by authoring and distributing a number of applications written to allow students to interact with visualizations of key concepts using their handheld computers. Downloadable from the campus wireless network and used in class (large lecture and discussion) the contribution of these applications to the course was substantial. The handheld computers and accompanying visualization software served as course companions, instantly providing meaningful content and engaging instruction anywhere the student went, on campus or off. Students rated the concept visualization software as the most useful aspect of the course. The success of this initiative leads to several important conclusions about the relationship of handhelds to laptops as learning tools, the importance of visualization software and the successfull integration of companion technology into the CS1 curriculum.
Action research as a tool for promoting teacher awareness of students' conceptual understanding
Authors: Haberman Bruria , Lev Ela , Langley Dorothy
Published: July 2004

Assimilating a new CS curriculum requires appropriate inservice training. The emphasis in the new CS curriculum upon conceptual understanding requires teachers to become aware of characteristic ways in which students construct their knowledge and of common student difficulties. In this paper we describe a regional CS teacher workshop in which action research was used to trigger changes in teachers' knowledge and approach and especially to promote awareness of students' conceptual understanding. The favorable teacher evaluation of the workshop, and the action research products indicate that the workshop design promoted the beginning of a teacher change necessary for assimilating the new CS curriculum and establishing a collaborative community of teachers.
The novice programmers' syndrome of design-by-keyword
Authors: Ginat David
Published: July 2004

In the course of reading the description of a given assignment, it is natural that associations with design patterns directly tied to explicit keywords or phrases in the assignment text will evolve. However, explicit keywords may not always be the basis for the desired solution. Implicit cues may yield a better outcome. This paper presents a study of novice programmers who are misguided by explicit keyword associations. The study shows that students' tendency to "design-by-keyword" may sometime lead them to incorrect or inefficient programming solutions. The study displays student solutions to three CSI problems, each answered in three different ways. The first two ways reflect undesirable "design-by-keyword" outcomes, and the third way encloses the desired solution, which demonstrates the importance of looking for implicit cues.
A tool to develop electronic course books based on WWW technologies, resources and usability criteria
Authors: Crescenzi Pilu , Innocenti Gaia
Published: July 2004

An electronic course book (ECB in short) is a learning module consisting of hyperdocuments with a functional use of interactivity and multimedia, presented on the WWW and/or CDROM [1]. In this paper we propose an ECB producer application, which can assist any author in the development of an ECB based on WWW usability criteria and which presents a collection of several multimedia elements which can enhance the process of learning and which differentiate an electronic course book from a classical paper book. The ECB, which represents an electronic form of classroom support, will turn out to be useful both to teachers, since they will take advantage of the slide-based presentation of the text and of the several simulation tools included in the ECB, and to students, since they will be able to learn by reading, by doing and by answering.
Using departmental surveys to assess computing culture
Authors: Meeden Lisa , Newhall Tia , Blank Doug , Kumar Deepak
Published: July 2004

Male and female students often hold different views of the culture within the same computer science department. These differences may, in part, account for why women are underrepresented in computer science. We found that surveying students about their views of our departments' environments was an important first step in evaluating the cultures of our own departments, in determining what issues needed to be addressed, and in determining how to address them. Our survey results revealed some problems in our classroom and lab environments, and showed that there are gender differences in students' perceptions of our departments. We describe a set of changes that were implemented in response to our findings. These solutions are specifically designed to address problems that we discovered through our student survey, but they are not all original to us. The contribution of our work is in demonstrating how surveying is critical to identifying and understanding problems in our departments. We argue that a process of continually surveying students is vital to the maintenance and evolution of a healthy computer science program.
HTTPExplorer
Authors: Turau Volker
Published: July 2004

This paper presents HTTPExplorer, an interactive tool to explore the Hypertext Transfer Protocol. The intention is to use the tool in a course on web-based applications to support the learning of HTTP, the most significant protocol used on the internet today. A web-based user-interface allows students to contact any HTTP-Server connected to the internet, to issue a request and to make the data flow between a client and the server completely visible. The tool can be used by novices to get first experience with HTTP and by advanced users to experiment with more complex features. We also report about some initial experience gained in the usage of HTTPExplorer in a real course.
Incorporating bioinformatics in an algorithms course
Authors: D'Antonio Lawrence
Published: July 2004

In this paper we examine ways in which ideas from the exciting new field of bioinformatics can be used in an algorithms course intended for computer science majors. Bioinformatics studies biological sequences such as DNA or protein that are the building blocks of life. Algorithms that involve searching, matching, or combining such sequences are primary tools in bioinformatics. These algorithms use many key ideas that are important to the computer science major, such as dynamic programming. In addition, bioinformatics makes for an interesting and timely application that can enliven the algorithms course.
Experiences with IDEs and Java teaching
Authors: Murray Keitha A. , Heines Jesse M. , Kölling Michael , Moore Tom , Wagner Paul J. , Schaller Nan C. , Trono John A.
Published: July 2004

The environment chosen to teach Java can have a profound effect on students' abilities to learn the language. Panelists will report on their experiences using different Java Interactive Development Environments (IDEs) to teach Java and what they identify as the strengthens and weaknesses of each IDE. Each panelist will discuss the most important features of the IDEs and related teaching pedagogies to address "what works and what doesn't" when teaching Java.
IEEE-CS/ACM computing curricula
Authors: Sobel Ann E. K. , Lethbridge Tim
Published: July 2004

One of the problems in advancing the state of the software engineering discipline is the inadequate preparation of students entering the profession from undergraduate computing programs. This panel reports on the IEEE-CS/ACM Computing Curricula project and the guidance it will provide for developing undergraduate software engineering programs. In particular, the panel will address the development process used to construct the Software Engineering Volume, the contents of the first draft of the Volume, and the application of the software engineering curriculum guidelines to international curriculum models.
Computer engineering curriculum development
Authors: Impagliazzo John
Published: July 2004

This poster describes the development of a curriculum for the area of computer engineering following the Computing Curricula 2001 effort. It explains the organization of the intended report and the elements that encompass the body of knowledge for the proposed curriculum.
A multi-level distance learning-based course for high-school computer science leading-teachers
Authors: Ragonis Noa , Haberman Bruria
Published: July 2004

In this poster we present a flexible model for a multi-level distance learning-based teacher training. The model was implemented to introduce curricular and pedagogical aspects of teaching logic programming (LP) to high-school computer science in-service leading-teachers.
Learning to develop GUIs in Java using closed labs
Authors: Leska Chuck
Published: July 2004

This paper reviews an experiment in which a closed lab was used to deliver instruction on developing graphic user interfaces, GUIs, within a CS 1 course using Java
Software engineering concepts for multimedia development
Authors: Cizmar Dawn
Published: July 2004

This presentation reports results, experience and ongoing efforts to teach software engineering skills to developers of instructional technology. Software engineering concepts were presented to faculty who had little prior experience with computer science or system development techniques. These faculty planned to develop technology enhancements for their courses, requiring multimedia and other implementation skills. Analyzing the experiences later led to several projects to address the lack of knowledge and effective practice among faculty and other developers, including professional staff and students.
Using semiotics to analyze the efficiency of a model in teaching
Authors: Fone William
Published: July 2004

Semiotics is used here to explain why spreadsheets make effective teaching models.
Automatically creating personalised exercises based on student profiles
Authors: Yong Chye-Foong , Higgins Colin
Published: July 2004

Course Marker (CM - previously called Course Master), is a CAA system that marks programming code and diagrams and is a reengineered version of the Ceilidh system. It has been used in many higher institutions around the world, including at its developers' base, the School of Computer Science & IT, at the University of Nottingham. CM allows teachers to set exercises, and students to submit their solutions to these exercises. Upon each submission, students obtain immediate marks and detailed feedback from the system [4].The system has been well received and is excellent at marking exercises. However it can be extended in a variety of ways. This paper describes such an enhancement based on customising the questions to individual students by generating a personalised set of questions. Currently, all students are given the same set of exercises.To improve the learning environment, the idea is to use tailored multi-modal questionnaires. Firstly new types of question have been added to CourseMarker functionality. Initially these are the fixed response type of question such as multiple choice and multiple answer. Later more sophisticated types based on the full power of CourseMarker will be added. These are combined with currently available programming exercises and diagram based questions into a multi-modal questionnaire consisting of multiple types of question.Initially the questions in a given questionnaire are fixed by the teacher and pre-selected from a question bank. The next step is to allow the system to choose a set of questions dynamically from the question bank so as to give each student a different questionnaire.A major enhancement to this, and the main thrust of the research, is to tailor each questionnaire individually to each student at an appropriate level of difficulty for that students' ability. That is we will generate personalised exercises for each student, according to some individual student profile.Metadata for the students' profile, such as their background, their current level of knowledge on pre-requisite and current topics and subjects, and their preferred or best learning modes, are to be stored in a user model [2]. All this information can be obtained by interacting with applications such as Knowledge Tree [3] and WHURLE [1] and by using the outcome of earlier questionnaires.This poster presentation will explain the work involved to incorporate these enhancements.
Classroom presentation from the tablet PC
Authors: Anderson Richard J. , Anderson Ruth , VanDeGriff Tammy , Wolfman Steven A. , Yasuhara Ken
Published: July 2004

We have developed and deployed a lecture presentation system in which the instructor uses a Tablet PC as a presentation device. The system was deployed in six university courses in Autumn 2002 and has been favorably received by students and instructors. In our system, the instructor holds a pen-based computer that is wirelessly networked with another computer driving the classroom projector. The instructor displays slides from the tablet and can write on top of them. Various navigation and control facilities are available.
Teaching IT in secondary education through problem-based learning could be really beneficial
Authors: Ekaterini Georgouli , Spyros Bakoyannis , Panagiotis Giannakoulias
Published: July 2004

This article attempts to stress the need for extended research on the use of constructivist's elements for the teaching of Information Technology in Secondary Education. In our case study, we tried to draw conclusions by questioning adolescents for their Problem-Based Learning experience during a three-month Internet-Programming course.
Using the NSDL and CITIDEL to enhance teaching
Authors: Knox Deborah , Cassel Lillian N. , Impagliazzo John
Published: July 2004

We present an overview of the National Science Digital Library, NSDL, and focus on one of the partner projects it supports. The computing and Information Technology Interactive Digital Educational Library (CITIDEL) harvests metadata from repositories and collections, and provides tools to customize learning with these resources. CITIDEL's integrated tools guide the user to create instructional environments that enhance the learning experience. Additional tools available from NSDL are included in this presentation to complete the picture. Information on integrating new collections and materials into CITIDEL is included.
Difficulties learning computer architecture
Authors: Mirmotahari Omid , Holmboe Christian , Kaasbøll Jens
Published: July 2004

During a course on computer architecture, assembler, C programming, network and communication, 57 out of 300 students were followed closely by questionnaires and tests in order to evaluate their learning of computer architecture. The results indicate both that the students' understanding of logic gates and Boolean algebra is poorer than preferred, and that the students also have difficulties grasping the implementation of higher level constructs in low level architecture features. Better results might have been achieved if the teaching of architecture was closely linked to the students' previous training in programming.
Using CITIDEL resources to support documenting objectives and outcomes
Authors: Cassel Lillian N.
Published: July 2004

This poster demonstrates connecting objectives, outcomes and CITIDEL resources to improve course preparation. The example used is mobile computing.
Teaching algorithm efficiency in a CS1 course SBTa different approach
Authors: Gal-Ezer Judith , Vilner Tamar , Zur Ela
Published: July 2004

Having found that algorithm efficiency is difficult for students to grasp, we advocate a different didactic approach in the introductory CS course (CS1). By exposing students to a number of possible solutions to the same problems, students internalize the concept of a more efficient algorithm.
Why project courses sometimes widen the experience gap among students
Authors: Barker Lecia J. , Garvin-Doxas Kathy
Published: July 2004

Choices by students and faculty about their roles in group learning activities can result in students not learning new skills/knowledge. Faculty must be cautious about how students are grouped and should educate students about group roles to avoid problems.
Learning computer graphics by programming
Authors: Nodelman Vladimir
Published: July 2004

One of the problems in teaching and studying Computer Graphics is actual linking between theory and practice: theoretical issues are complex and difficult to visualize while using programming techniques like OpenGL without a deep understanding of the theoretical basis prevents from exploiting the full potential of these powerful aids.Existing Computer Graphics courses are varying from pure theory, via using ready programs for demonstrations and illustrations up to systematic use of programming elements as the important component of a course.This presentation describes the implementation of two of these strategies, used by the author is his computer graphics courses, in order to enhance the links between theory and practice
Codewitz
Authors: Kujansuu Esa , Kulmala Marko
Published: July 2004

The students of basic programming courses encounter often very serious learning problems. This is mostly due to the fact that even basic programming concepts and structures are abstract and need to be understood before a student can learn more practical issues. If these concepts remain hidden for the students they tend to drop out or finish the course with low marks when trying to learn more advanced concepts without the basic knowledge. To avoid the drop out problem there has to be an effective way to help the students with difficulties during the first steps of programming studies. It is a fact that there hardly ever exists any extra resource for these students. With interactive material the students can try by themselves to reach such level of skills to be able to learn more.Codewitz-project was set up to try to correct this problem in basic programming courses. The basic idea of the project is based upon the idea of sharing. There are three main goals in this project:Developing and producing interactive material for basic programming coursesImplementing a material bank for storing and sharing the resource with the project partnersCreating a functioning network of experts who deal with this problem every day.This demonstration will illustrate the idea of the material, the production process and the use of it. The project is open to any institution interested in taking part in the development work. The project website: http://www.codewitz.net.
A visualization of the primal simplex algorithm for the assignment problem
Authors: Papamanthou Charalampos , Paparrizos Konstantinos
Published: July 2004

An educationally-oriented Visualization Software used to assist the teaching of the Primal Simplex Algorithm for the Assignment Problem is presented.
Peer evaluation in an algorithms course
Authors: Papalaskari Mary-Angela
Published: July 2004

Peer evaluation is used in an algorithms course to highlight the importance of good documentation and professional presentation.
Creating learning environments that support interaction
Authors: Garvin-Doxas Kathy , Barker Lecia J.
Published: July 2004

In previous work [1], we characterized the communication climate in the traditional CS program as a defensive communication climate [2]. As a practical extension of this work, in this brief presentation we will present a few practical techniques for creating the sort of classroom environment that encourages students to participate and also supports group learning.
Global software development
Authors: Lanubile Filippo , Damian Daniela , Oppenheimer Heather L.
Published: July 2004

The International Workshop on Global Software Development was held in Portland (Oregon, USA) on May 9 2003, as part of the International Conference on Software Engineering 2003. A multicultural group of twenty-five people contributed to a successful workshop that debated the continued challenges of software development in global teams. The workshop consisted of an invited talk, sixteen short presentations, and fruitful discussions. We present an overview of the workshop motivation and then focus on the workshop's technical program. The workshop web site, including papers and slides, can be found at .
Using refactoring and unification rules to assist framework evolution
Authors: Cortes Mariela , Fontoura Marcus , Lucena Carlos
Published: July 2004

Although object-oriented software development has experienced the benefits of using frameworks, a thorough understanding of how to change them to meet evolving requirement needs is still object of research. Therefore framework development is very expensive, not only because of the intrinsic difficulty related to capturing the domain theory, but also because of the lack of appropriate methods and techniques to support the evolution and redesign of the framework architecture. This paper proposes the use of refactoring and unification rules to assist framework evolution. The approach is illustrated through the JUnit testing framework.
Quantifiable architecting of dependable systems of embedded systems
Authors: Liang Sheldon X. , Luqi Valdis Berzins
Published: July 2004

Architecture is a critical aspect in the successful development and evolution of dependable systems of embedded systems (SoES). Quantifiably architecting such systems involves establishing consensus from the particular perspectives of quality attributes. Unfortunately, there are few established approaches for rapidly prototyping architecture to identify key architectural artifacts that carry quantifiable constraints throughout the software development processes. This paper presents a quantifiable architectural approach for dependable SoES using rapid prototyping. The approach provides a set of rules (patterns) governing system composition. With quantifiable constraints attached to compositional patterns, the approach also establishes mappings between perspective modeling of dependability acquisition, constraint attachment, and property monitoring. Finally, it provides a rationale for translating timing and synchronous constraints into monitored properties attached to the auto-generated quantifiable architectural framework as an architectural context for quantifiable assessment and architectural evolution. Thus these properties are effectively and practically computable for dynamic monitoring at runtime.
From UML activity diagrams to Stochastic Petri nets
Authors: López-Grao Juan Pablo , Merseguer José , Campos Javier
Published: July 2004

Over the last decade, the relevance of performance evaluation in the early stages of the software development life-cycle has been steadily rising. We honestly believe that the integration of formal models in the software engineering process is a must, in order to enable the application of wellknown, powerful analysis techniques to software models. In previous papers the authors have stated a proposal for SPE, dealing with several UML diagram types. The proposal for malizes their semantics, and provides a method to translate them into (analyzable) GSPN models. This paper focuses on activity diagrams, which had not been dealt with so far. They will be incorporated in our SPE method, enhancing its expressivity by refining abstraction levels in the statechart diagrams. Performance requirements will be annotated according to the UML profile for schedulability, performance and time. Last but not least, our CASE tool prototype will be introduced. This tool deals with every model element from activity diagrams and ensures an automatic translation from ADs into GSPNs strictly following the process related in this paper.
Expressing performance requirements using regular expressions to specify stochastic probes over process algebra models
Authors: Argent-Katwala Ashok , Bradley Jeremy T. , Dingle Nicholas J.
Published: July 2004

This paper describes how soft performance bounds can be expressed for software systems using stochastic probes over stochastic process algebra models. These stochastic probes are specified using a regular expression syntax that describes the behaviour that must be observed in a model before a performance measurement can be started or stopped. We demonstrate the use of stochastic probes on a 661, 960 state parallel, redundant web server model to verify its passage-time performance characteristics.
Towards automatic compositional performance analysis of component-based systems
Authors: Grassi Vincenzo , Mirandola Raffaela
Published: July 2004

To make predictive analysis an effective tool for component-based software development (CBSD), it should be, as much as possible:compositional, to allow the re-use of known information about the properties of existing components, andautomatic, to keep the pace with the timeliness and cost-effectiveness promises of CBSD. Towards this end, focusing on the predictive analysis of performance properties, we define a simple language, based on an abstract component model, to describe a component assembly, outlining which information should be included in it to support compositional performance analysis. Moreover, we outline a mapping of the constructs of the proposed language to elements of the RT-UML Profile, to give them a precisely defined "performance semantics", and to get a starting point for the exploitation of proposed UML-based methodologies and algorithms for performance analysis.
Application of the operational profile in software performance analysis
Authors: Alzamil Zakarya
Published: July 2004

Most of the existing operational profile studies have been proposed for software reliability. Operational profile describes how the program to be used. Our experience with software performance analysis shows that the operational profile may play a role in the performance analysis of a program. In this paper we investigate the application of the operational profile in software performance analysis. We introduce a new type of performance deficiency referred to as redundant computation and show how the operational profile can guide in detecting such deficiency. Our initial experiment shows the application of operational profile in enhancing program's performance.
An autonomic failure-detection algorithm
Authors: Mills K. , Rose S. , Quirolgico S. , Britton M. , Tan C.
Published: July 2004

Designs for distributed systems must consider the possibility that failures will arise and must adopt specific failure detection strategies. We describe and analyze a self-regulating failure-detection algorithm that bounds resource usage and failure-detection latency, while automatically reassigning resources to improve failure-detection latency as system size decreases. We apply the algorithm to (1) Jini leasing, (2) service registration in the Service Location Protocol (SLP), and (3) SLP service polling
Exploring architectural scalability
Authors: Brataas Gunnar , Hughes Peter
Published: July 2004

We describe a structured, hierarchic approach to exploring the scalability of IT systems architectures. An architecture is considered to be scalable over a particular set of requirements if the physical resource usage per unit of capacity remains roughly constant. For completeness, both requirements and capacity must be defined in the three dimensions of processing, storage and connectivity. Interactions between the three dimensions are considered, as are various forms of departure from non-uniform scaling. Scalability is explored via a combination of measurement and static and dynamic models. Appropriate scale-invariants are introduced to eliminate congestion effects and packaging issues from the analysis. This paper focuses on processing and to a lesser extent, on storage. The method is applied to a practical case study of Transigo, a J2EE-based software platform used in the Norwegian banking industry. We find that understanding the relationship between replication and upgrade for systems, subsystems and devices is key to guiding the exploration of scalability.
Topology based automation of distributed applications management
Authors: Bellur Umesh
Published: July 2004

With the widespread use of distributed computing in the enterprise, there have been significant advances in development paradigms for these applications. Server side component models have considerably simplified development and the complexity has now shifted to the operational side of these applications. The increase in operational complexity has reached a point where it is no longer feasible for humans to manage the applications required to run an enterprise. The initial steps to provide self managing applications are now being taken -- a paradigm known as "autonomic computing" is in it's infancy of evolution. There have been numerous proposed models of how one achieves self management. In this position paper, we formulate the research problems and basis for "lights out" management of enterprise application environments.
Computing the performability of layered distributed systems with a management architecture
Authors: Das Olivia , Woodside C. Murray
Published: July 2004

This paper analyzes the performability of client-server applications that use a separate fault management architecture for monitoring and controlling of the status of the application software and hardware. The analysis considers the impact of the management components and connections, and their reliability, on performability. The approach combines minpath algorithms, Layered Queueing analysis and non-coherent fault tree analysis techniques for efficient computation of expected reward rate of the application.
Generating realistic workloads for network intrusion detection systems
Authors: Antonatos Spyros , Anagnostakis Kostas G. , Markatos Evangelos P.
Published: July 2004

While the use of network intrusion detection systems (nIDS) is becoming pervasive, evaluating nIDS performance has been found to be challenging. The goal of this study is to determine how to generate realistic workloads for nIDS performance evaluation. We develop a workload model that appears to provide reasonably accurate estimates compared to real workloads. The model attempts to emulate a traffic mix of different applications, reflecting characteristics of each application and the way these interact with the system. We have implemented this model as part of a traffic generator that can be extended and tuned to reflect the needs of different scenarios. We also present an approach to measuring the capacity of a nIDS that does not require the setup of a full network testbed.
A framework to model and analyze the performability of mobile software systems
Authors: Bracchi Paola , Cortellessa Vittorio
Published: July 2004

The early validation of non-functional requirements of software systems is becoming a very stringent concern, especially in two domains: heterogeneous computing environments and interactive systems. In the former case the issue arises from the need of effectively exploiting the resources and capabilities that those environments may provide. In the latter case non-functional attributes (such as performance, reliability and availability) are peculiar for guaranteeing high levels of quality of services to users. Mobile software systems (e.g. web connected mobile phones) embrace both domains and therefore claim for accurate nonfunctional validation since the early phases of the software development process.This paper focuses on model based analysis of the performability of mobile software systems. We introduce a general framework that encompasses performance, dependability and mobility of software systems and that supports the specification and estimate of performability measures. The framework is based on the Stochastic Activity Networks notation. We also show the viability of our approach at work on a simple network management scenario.
A performance analysis approach based on the UML class diagram
Authors: Alsaadi Ahmad
Published: July 2004

A data model, or UML class diagram of a software system, is of central importance to the computing time and the disk usage a software system exhibits. It can be normalized or denormalized to better utilize the components of a computer system or to offer acceptable performance values.This paper describes an approach to software performance analysis that is based on the UML class diagram. It predicts the performance values for use cases operating on persistent data collections as well as whether and how much normalization or denormalization a UML class diagram may need, in order to ensure that these use cases meet their performance objectives.