bluuebunny/crossref_metadata_2025 huggingface dataset:
On serving as department chair
Authors: DeLoatch Sandra , Walker Henry , Young Frank H.
Published: July 2004

Each year a small group of computer science educators are selected to become chairs of their departments. This experience is often referred to as "losing the lottery." The panelists have a different view. We believe that department chairs make important contributions to the success of their departments. Department chairs help new faculty develop as educators and professionals. Department chairs help to create an environment where students and faculty can enjoy their work and be productive. Department chairs can facilitate curriculum development and change, thereby helping keep the department's offerings current.The panelists have experience in a variety of educational environments. All have served as department heads. All have had to deal with the normal problems that department heads deal with - recruiting new faculty, obtaining funds for equipment, getting adequate funds for faculty salaries, acquiring technical support personnel, dealing with rapid increases in the number of majors, arranging teaching schedules, assisting with grant proposals, etc.Most department chairs have little or no guidance as they begin their tenure. This panel is an attempt to alleviate this problem. The panelists believe that their experiences can help new department chairs adjust to the multiple and sometimes conflicting demands of their new job.
The role of language paradigms in teaching programming
Authors: Van Roy Peter , Armstrong Joe , Flatt Matthew , Magnusson Boris
Published: July 2004

The purpose of this panel is to confront the wide variety of opinions on the role of language paradigms in teaching programming. We have selected four divergent opinions:

Armstrong says that concurrent programming is considered difficult because it is taught in the wrong paradigm, namely imperative or object-oriented programming. Instead, concurrency should be taught using a paradigm that makes it simple.

Flatt says that everyone should be taught how to program, not just computer science majors. Further, programming should be taught as an extension of what students already know, which is algebra. More important than a particular paradigm, however, is teaching students a design process.

Magnusson says that object-oriented programming must be the first and principal paradigm, because it is best for teaching how to analyze problems and structure solutions. Other paradigms can be taught after students have a solid understanding of OO.

Van Roy says that programming should be taught in terms of concepts, not paradigms. Common paradigms (functional, OO, etc.) then appear naturally, depending on the concepts used.

.The panel will confront these opinions to enrich our understanding of how to teach programming.
Java in the morning...Java in the evening...Java in 2004
Authors: Drysdale Scot , Hromcik Judith , Weiss Mark Allen , Hahne Reg
Published: July 2004

With the Java language replacing C++ on the 2004 AP CS Exam, teachers need to be informed about the changes that must be implemented to support an OO approach to programming. This special session will include a retrospective look at the motivation behind the change to an object-oriented language, the process undertaken to select a testable language subset, the need to continue the development and classroom implementation of a Case Study, and a look at how the shift from an object-based approach to programming in C++ to an OO approach in Java leads to curriculum modification.The AP CS Development Committee's charge is to not only provide a comprehensive testing mechanism, but also advise, through various publications, a direction that high school teachers should take in preparing a foundation for more advanced student studies during college. This special session will bring together two college and two high school members of the AP CS Development Committee to share some of their insights into how the experts do it. Time will be provided to discuss participant's questions.
Report on the NSF major educational funding initiative for a National Science, Technology, Engineering, and Mathematics Education Digital Library (NSDL) with special emphasis on the Computing Education component
Authors: Cassel Lillian N. , Impagliazzo John , Lally Ann , Fox Edward A. , Pérez-Quiñones Manuel A. , Prey Jane
Published: July 2004

The NSDL consists of collections of materials accessible online, as well as many tools and services intended to enhance learning. Tools and services will support students and as well as faculty. This session will provide a status report on the state of the NSDL, its content, tools, and services. The session includes specific presentations of several services included in the NSDL. Session attendees discuss current and proposed initiatives, and offer suggestions about needs of highest priority.
Toward a K-12 computer science curriculum
Authors: Tucker Allen , Deek Fadi , Jones Jill , McCowan Dennis , Stephenson Chris , Verno Anita
Published: July 2004

This special session will report on the work of the ACM K-12 Computer Science Curriculum Committee, whose charge is to design a model curriculum for K-12 computer science that can be widely implemented. It will also gather feedback from attendees on the content and direction of that work.
The greedy trap and learning from mistakes
Authors: Ginat David
Published: July 2004

Educators' approach towards their students' mistakes can have significant impact on the students. This paper presents a rather less considered approach of teaching by capitalizing on mistakes. In the course of teaching our students algorithm design, we noticed the phenomenon of students' "over-reliance" on intuition rather than rigor. In particular, we noticed a repeated erroneous trend of turning to intuitive, but inadequate greedy algorithmic solutions. We capitalized on the student errors for influencing their attitude and beliefs regarding intuition and rigor. The paper displays the student errors and our capitalization-on-errors approach, with colorful and novel algorithmic tasks.
DBMS course
Authors: Ramakrishnan Sub , Nwosu Emeka
Published: July 2004

In this paper, we discuss a software tool we have developed for use in undergraduate DBMS courses, that provides: (i) a web-enabled database set up and administration facility for faculty use, and (ii) web-based database projects that may be assigned to students.We discuss the motivation for our work and the objectives underlying the design of the tool. The significance of our work is two-fold. First, it should help the instructor in the set up, management, and monitoring of student database accounts. Second, it provides the students with a feel for the organization and use of contemporary web-enabled database applications.
Gender differences in computer science students
Authors: Beyer Sylvia , Rynes Kristina , Perrault Julie , Hay Kelly , Haller Susan
Published: July 2004

We examined gender differences and differences in Computer Science (CS) majors vs. non-majors in ability in quantitative areas, educational goals and interests, experience with computers, stereotypes and knowledge about CS, confidence, personality, support and encouragement, stress and financial issues, gender discrimination, and attitudes toward the academic environment in CS. What is unique to this investigation is its multivariate nature. While others have studied these variables in isolation, our study looks at them collectively to identify important interactions among variables. This will eventually allow us to identify a profile of women who pursue careers in CS. The findings are reported in detail below. Particularly noteworthy is that men had more confidence in using computers than did women even when statistically controlling quantitative ability. In fact, female CS majors had less computer confidence than did male non-majors.
An expanding pipeline
Authors: Adams Joel C. , Bauer Vimala , Baichoo Shakuntala
Published: July 2004

The gender imbalance in computer science in the U.S. and other countries has attracted much attention. This paper presents - for comparison - the computing-related gender ratios in Mauritius, a developing country in the Indian Ocean. These ratios suggest that far from being a universal phenomenon, the gender imbalance in the U.S. is a cultural problem.
Teaching the SIMD execution model:
Authors: Ortiz Ariel
Published: July 2004

This paper gives an overview of what the SIMD (single-instruction/multiple-data) parallel execution model is, and provides an approach for presenting it to undergraduate students. We specifically propose a few assembly language idioms and programming projects which we have successfully used in the past to teach this non-trivial topic.
Running research-oriented final year projects for CS and IS students
Authors: Olsson B. , Berndtsson M. , Lundell B. , Hansson J.
Published: July 2004

In this paper we discuss the difficulties of designing and running a final year project course for computer science and information systems students. In particular, we present the design of a research-oriented final year project course, where the aim is to develop the student's critical thinking and research skills. We also discuss the lessons learnt during the seven years that the course has been given.
New roles for students, instructors, and computers in a lab-based introductory programming course
Authors: Clancy Michael , Titterton Nate , Ryan Clint , Slotta Jim , Linn Marcia
Published: July 2004

This paper describes our efforts to develop a new lab-based course format for computer science instruction. Building on learning science research, we created a flexible new technology platform to support students and their instructor as they participated in this new form of instruction. Students work collaboratively on Web-based activities while the instructor interacts with students in a tutorial role. The paper describes our system in detail, outlines the organization of the course that used it, and reviews and evaluates the pilot results. We then discuss the implications for computer science instruction and research in higher education.
Effectiveness of online assessment
Authors: Woit Denise , Mason David
Published: July 2004

For five academic years we have engaged in an on-going study of the effectiveness of online assessment of student programming abilities for introductory programming courses in Computer Science. Our results show that online evaluation can be implemented securely, efficiently, and can result in increased student motivation and programming efficacy; however, unless online components are integrated throughout the course evaluations, student competence will be underestimated. Our data reveals disadvantages of online evaluations, but also shows that both students and faculty benefit when online evaluations are implemented appropriately.
Identifying and correcting Java programming errors for introductory computer science students
Authors: Hristova Maria , Misra Ananya , Rutter Megan , Mercuri Rebecca
Published: July 2004

Programming in Java can be a daunting task for introductory students, one that is only compounded by the cryptic compiler error messages they see when they first start to write actual code. This article details a project conducted by faculty and advanced students in the creation of an educational tool for Java programming, called Expresso. This paper discusses some existing programming tools, explains their drawbacks, and describes why Expresso is different. We also include a detailed list of typical errors made by novice programmers, used in the construction of the Expresso tool.
Using remote logging for teaching concurrency
Authors: Robbins Steven
Published: July 2004

Students often have difficulty visualizing, understanding and debugging concurrent programs. Programming assignments involving concurrency are also difficult to grade. The output alone is not sufficient because the print statements from cooperating threads or processes can interfere with each other and garble the results. The remote logging tool described here allows multiple processes or threads to atomically log messages to a local or remote host. Different views of the messages are available in real time through a graphical user interface (GUI). The tool consists of two parts, a library for adding logging commands to a user program and a GUI for presenting different views of the logged messages. A separate logging library is needed for each programming language (e.g., C, C++, Java), but a single GUI works with all of these. A C logging library and a general GUI are available on the web.
Redesigning introductory computer programming using multi-level online modules for a mixed audience
Authors: Herrmann Nira , Popyack Jeffrey L. , Char Bruce , Zoski Paul , Cera Christopher D. , Lass Robert N. , Nanjappa Aparna
Published: July 2004

We report here on an extensive redesign and unification of the Introductory Computer Programming sequences offered to computer science, computer engineering, information science and digital media majors. The redesign is intended to improve student learning while reducing costs. The approach makes use of substantial Web-based course material and course management tools, including multi-level online modules that individualize instruction and enable students to self-schedule learning each week. Each module covers a particular aspect of computer programming at different levels of knowledge. Students are assigned work and reading from the module at a level appropriate to the objectives of the long-term goals of their major. This allows students in different majors to acquire the appropriate skill level for each technique and concept. Peer mentors and teaching assistants provide assistance online or in person. In the future, we plan to expand the self-scheduling aspect of the course to allow students to enter the course at different modules, depending on their previous knowledge.
A compiler for teaching about compilers
Authors: Baldwin Doug
Published: July 2004

Projects in which students write a small compiler are common in compiler design courses, but even a small compiler can be daunting to students with no prior compiler-writing experience. When I recently taught compiler design, I developed a very small language with a highly modular compiler, focusing the project on implementing the core parts of a compiler without requiring students to build all the infrastructure from scratch. This paper describes the language and its compiler, and their successes (and occasional limitations) for teaching compiler design.
Breadth-also
Authors: Powers Kris D.
Published: July 2004

In the fall of 2002 our institution will begin teaching a new computer science curriculum based on the guidelines set forth in Computing Curricula 2001. Of particular interest in this new curriculum is our "breadth-also" approach to a lower-level core. In general, a breadth-also model incorporates topics from across the discipline of computer science into an expanded, programming-first introductory sequence. In this paper we present our specific implementation of this model, and argue its potential to significantly improve learning.
A laboratory-based course on internet security
Authors: Mateti Prabhaker
Published: July 2004

We developed a laboratory-based course on Internet Security. The course is aimed at the senior undergraduate. This paper discusses the course and explains how others can set up their own labs to teach this course. All the laboratory work is conducted in a laboratory of PCs running Linux. We developed lecture notes for the course, and a web site to widely disseminate these materials.
Object centered design for Java
Authors: Adams Joel , Frens Jeremy
Published: July 2004

Object-centered design (OCD) is a methodology developed to help novice C++ programmers learn to design software. By adapting OCD for use with Java, we can reduce the number of phases in OCD from five to three, and introduce object-oriented design (OOD) in CS-1 instead of CS-2.
An object-oriented refactoring of Huffman encoding using the Java collections framework
Authors: Wick Michael R.
Published: July 2004

Computer science has a relatively stable collection of time-tested pedagogical programming examples. With the infusion of object-oriented concepts into the core computer science curriculum, many of these examples are being replaced with newer examples that are more focused on demonstrating the particular object-oriented features of interest. But classic computer science examples can be refactored to include the important object-oriented topics as well, all the while maintaining the time-tested pedagogical benefits of the original example. This paper presents a case study of this refactoring by demonstrating how the classic Huffman encoding example can be modeled to integrate important object-oriented concepts.
ISSAC
Authors: Henderson Peter B.
Published: July 2004

The Indiana Student Software Awards Competition (ISSAC) was created to encourage students in the state of Indiana to improve their software development skills, to potentially consider a career in information technology, and to help stem the flow of graduates out of Indiana - "the brain drain". High school or college students who develop a software project for class, personal enrichment or corporate internships may submit a project. ISSAC 2003 is the third year of the competition. Finalist projects are judged at the annual Indiana Technology Summit, and students are awarded scholarships and plaques based upon the overall quality and functionality of their software.
Creating a computer science canon
Authors: Eisenberg Michael
Published: July 2004

Computer science has a reputation of being a discipline in a perpetual state of accelerated progress-a discipline in which our techniques, our hardware, our software systems, and our literature rarely exhibit a staying power of more than several years. While undeniably exciting, this state of continual intellectual upheaval can leave computer science students (and faculty) with a disturbing sense that there is no essential core of great work within the discipline. This paper describes a readings course entitled "Computer Science: the Canon" whose purpose is to counter this perception by exploring a set of "great works" in computer science. We describe our own (undoubtedly idiosyncratic) reading list used for the course, and discuss several central issues involved in offering such a course within a computer science curriculum.
Web annotator
Authors: Reed Dale , John Sam
Published: July 2004

The World Wide Web is increasingly becoming an integrated extension of users' computing environments, with content indexed and retrieved through Web browsers. Web browsers are increasingly being used as computer science curriculum delivery mechanism, for both books delivered as local content on CD ROMs as well as server-based material.Traditional computer science curriculum has often been presented through static printed media. What has been printed ahead of time in books or handouts can not be changed. Any changes would have to be attached externally by way of scribbled notes or explanations on the board. The Web gives us the technological affordances to change that, both for students and teachers.The original page remains unchanged, however the user's version of the page is filtered, adding, subtracting and changing web page elements, giving an enhanced view. A demonstration version of the Web Annotator can be downloaded from: http://logos.cs.uic.edu/Annotator.
A generic e-learning multiparadigm programming language system
Authors: Labra Gayo J. E. , Morales Gil J. M. , Fernández Álvarez A. M. , Chigne H. Sagastegui
Published: July 2004

We describe the main features of an Internet based distance learning environment that we are developing to teach a course on logic and functional programming for computer science students. The main goal of the system is to provide a minimal set of capabilities for a generic interpreter that will be instantiated for different programming languages and paradigms. The architecture of the system is based on the use of XML and web services to facilitate the integration and independence between the different development platforms and systems.
Computer science education in Italy
Authors: Cartelli Antonio
Published: July 2004

This paper discusses a brief overview of the Italian school system and the different ways it introduces computer science and information technology in the various schools. Included is a section on high school computing education and its evolution during the past decades as well as a review of the initiatives being undertaken by compulsory schools and professional associations.
A new model for a required senior research experience
Authors: Schneider G. Michael
Published: July 2004

This paper describes a new way of implementing a required undergraduate research experience. In addition to the project itself, this experience also includes a senior capstone seminar that teaches students how to do research, a scholarly capstone paper, and a capstone conference that reproduces the feel of an actual scientific meeting. This paper describes these experiences along with an assessment of how it has worked in its first years of operation.
Interactive tools for computation theory
Authors: Hannay David G.
Published: July 2004

The web-based simulations encompass the six core abstract models of computation: finite-state, pushdown and Turing machines as well as regular expressions, context-free grammars, and recursive functions. All six simulations come packaged with predefined machines/expressions/grammars/functions. Users can also create machines, expressions, grammars, and functions from scratch. Each machine simulation traces arbitrary input as processed by the machine. The regular expression simulator tests if an entered list of words is part of the language of a regular expression, and generates random words represented by an expression. The context-free grammar simulator also generates words in the corresponding language. Finally, one can trace the evaluation of functions to a user-specified depth of recursion.
Comparing the template method and strategy design patterns in a genetic algorithm application
Authors: Wick Michael R. , Phillips Andrew T.
Published: July 2004

We present a genetic algorithm software project that serves to give students direct experience with choosing among multiple potentially applicable design patterns. We carefully constructed this project to illustrate the power of design patterns in supporting encapsulation while at the same time providing a single context in which to compare and contrast similar design pattern alternatives.
CS1 and CS2
Authors: Lorenzen Torben , Heilman Ward
Published: July 2004

The authors have designed an introductory sequence of programming courses. In order to keep the students interested and to add some fun to the course, all the programming assignments involve implementing computer games as Java applets. The entire course (including syllabus, assignments, and working source code) is available for download from the authors' web site.
Visual basic.Net as a first language
Authors: Bell Douglas
Published: July 2004

This paper assesses the utility of the Microsoft Visual Basic.Net programming language for teaching programming at a first level. The paper shows some comparisons with Java.
Operating systems projects
Authors: Howatt James
Published: July 2004

The author argues for the use of a real, albeit educational-strength, operating system, instead of simulators, on which to base operating systems projects. Minix developers have created a version that can be run on Windows and Unix platforms, without the need for hard-drive partitioning. Sample projects demonstrate how Minix can be used to reinforce operating systems concepts.
Simulation of load balancing algorithms
Authors: Soklic Milan E.
Published: July 2004

This article introduces a new load balancing algorithm, called diffusive load balancing, and compares its performance with three other load balancing algorithms: static, round robin, and shortest queue load balancing. The comparison of load balancing algorithms is made in three simulated client-server environments: a small-scale, intranet, and Internet environment. Experimental results of performance modeling show that diffusive load balancing is better than round robin and static load balancing in a dynamic environment, which manifest in frequent clients' object creation requests and in short objects' lifetimes. In this research, the diffusive load balancing algorithm is discussed in juxtaposition with the distributed client-server architectures.
Introducing the computer at a small liberal arts college
Authors: de Campo Leila
Published: July 2004

Description of a computer course to attract humanities oriented students. Current computer projects in Music, Art, Social Science and English were discussed. PL/I was the language used. In addition to the basic instructions, string manipulation and tape and disk processing were covered. Problems were geared to a non-mathematical group and covered alphabetic arrays and text scanning.
Automata
Authors: Rose Lawrence L. , Jones Neil D. , Barnes Bruce H.
Published: July 2004

This paper discusses a practical programming language specially designed to aid teachers and students of Computer Science courses which deal with mathematical machines. The first section outlines the motivation for developing such a language in the Computer Science curriculum. Next the criteria which were used to design the language are listed. The characteristics of Automata, the interpreter of this language, are discussed next. Concluding remarks note the results of using Automata as a teaching aid in three Computer Science courses at the Pennsylvania State University. The User's Guide to Automata is attached as the Appendix.
Development of a multifacetted undergraduate program in computer and information science
Authors: Mathis Robert F. , Kerr Douglas S.
Published: July 2004

Computer and Information Science Departments are usually organized, as was the one at The Ohio State University, by combining already existing courses in computer programming and applications from other departments into one department and adding a few extra courses. This paper is a report concerning how this was done at Ohio State and how the Department has developed since. Suggestions are also included for the organization of new departments at other schools. The report has been arranged in four main sections: a description of the development of the department at Ohio State, a unifying philosophy of the field, a description of the Ohio State undergraduate curriculum in Computer and Information Science, and suggestions for new curricula at other schools.
Ouchless I/O
Authors: Bailey T. E.
Published: July 2004

The teaching of FORTRAN I/O in a beginning computer programming course at Oklahoma State University has been totally integrated into the course in order to overcome the boredom and unpleasantness that students may experience when I/O is presented in a single block. Presenting the material in this manner has allowed students to handle rather sophisticated I/O early in the course with minimal difficulty.
Reusability issues in component-based development
Authors: Gill Nasib S.
Published: July 2004

Component-based development (CBD) advocates the acquisition, adaptation, and integration of reusable software components to rapidly develop and deploy complex software systems with minimum engineering effort and resource cost. Software reusability is an attribute that refers to the expected reuse potential of a software component. Software reuse not only improves productivity but also has a positive impact on the quality and maintainability of software products. The paper first discusses CBD and its associated challenges, and later outlines the issues concerning component reusability and its benefits in terms of cost and time-savings. Guidelines are presented to further assist software engineers in the development of reusable software products and to extract reusable components from existing software. Quality and productivity improvement activities within organisations adopting CBD can also benefit from the adoption of these guidelines.
Influences on the design of exception handling ACM SIGSOFT project on the impact of software engineering research on programming language design
Authors: Ryder Barbara G. , Soffa Mary Lou
Published: July 2004

There has long been a close association between research in software engineering and the design of programming languages. Part of the IMPACT project involves an exploration of the interrelations of these two fields and documentation in a report of how fundamental research in software engineering has been a valuable resource for programming language features commonly used today. The resulting report investigates the relationship by considering features in currently used languages, including exceptions, control and data abstractions, types, inheritance, concurrency and visualization mechanisms.This paper, exerpted from the report, focuses on the influence of software engineering research on the development of exceptions. The paper demonstrates that there is a symbiotic relationship between software engineering research and the design of exception handing in programming languages. Publication of these partial results is aimed at soliciting feedback and comments from both the programming languages and software engineering communities.
Assessing software projects
Authors: Jaaksi Ari
Published: July 2004

Executives need to assess ongoing software projects. They need truthful information to decide if projects should be redirected, cancelled, or strengthened. They need to verify that customer requirements are satisfied and business goals are met.We present a set of tools for executives to monitor the status of ongoing software projects. These tools allow executives that are not experts of software engineering to assess requirements, software architectures, development projects, and development organizations. Our tools, used commonly at Nokia and elsewhere, utilize use cases, views to architecture, frequent builds, and testing statistics. The fact that many projects already utilize these tools for software creation makes it easy to extend their use to serve executives and business management. We explain how managers can use these tools to get information, how to interpret this information, and how to integrate the tools into the interaction between the managers and their project teams.
A strategy for efficiently verifying requirements
Authors: Jeffords Ralph D. , Heitmeyer Constance L.
Published: July 2004

This paper describes a compositional proof strategy for verifying properties of requirements specifications. The proof strategy, which may be applied using either a model checker or a theorem prover, uses known state invariants to prove state and transition invariants. Two proof rules are presented: a standard incremental proof rule analogous to Manna and Pnueli's incremental proof rule and a compositional proof rule. The advantage of applying the compositional rule is that it decomposes a large verification problem into smaller problems which often can be solved more efficiently than the larger problem. The steps needed to implement the compositional rule are described, and the results of applying the proof strategy to two examples, a simple cruise control system and a real-world Navy system, are presented. In the Navy example, compositional verification %based on the compositional proof using either theorem proving or model checking was three times faster than verification %model checking using based on the standard incremental (noncompositional) rule. In addition to the two above rules for proving invariants, a new compositional proof rule is presented for circular assume-guarantee proofs of invariants. While in principle the strategy and %the rules described for proving invariants may be applied to any state-based specification with parallel composition of components, the specifications in the paper are expressed in the SCR (Software Cost Reduction) tabular notation, the auxiliary invariants used in the proofs are automatically generated invariants, and the verification is supported by the SCR tools.
Refinements and multi-dimensional separation of concerns
Authors: Batory Don , Liu Jia , Sarvela Jacob Neal
Published: July 2004

Step-wise refinement (SWR)
asserts that complex programs can be derived from simple programs by progressively adding features. The length of a program specification is the number of features that the program has. Critical to the scalability of SWR are multi-dimensional models that separate orthogonal feature sets. Let
n
be the dimensionality of a model and
k
be the number of features along a dimension. We show program specifications that could be

O(k
n
)

features long have short and easy-to-understand specifications of length
O(kn)
when multi-dimensional models are used. We present new examples of multidimensional models: a micro example of a product-line (whose programs are 30 lines of code) and isomorphic macro examples (whose programs exceed 30K lines of code). Our work provides strong evidence that SWR scales to synthesis of large systems.
Leveraging field data for impact analysis and regression testing
Authors: Orso Alessandro , Apiwattanapong Taweesup , Harrold Mary Jean
Published: July 2004

Software products are often released with missing functionality, errors, or incompatibilities that may result in failures, inferior performances, or user dissatisfaction. In previous work, we presented the
Gamma
approach, which facilitates remote analysis and measurement of deployed software and permits gathering of program-execution data from the field. In this paper, we investigate the use of the Gamma approach to support and improve two fundamental tasks performed by software engineers during maintenance: impact analysis and regression testing. We present a new approach that leverages field data to perform these two tasks. The approach is efficient in that the kind of field data that we consider require limited space and little instrumentation. We also present a set of empirical studies that we performed, on a real subject and on a real user population, to evaluate the approach. The results of the studies show that the use of field data is effective and, for the cases considered, can considerably affect the results of dynamic analyses.
Factors of software process improvement success in small and large organizations
Authors: Dybå Tore
Published: July 2004

Existing software engineering and organization development literature acknowledges that there are fundamental operational differences between small and large organizations. Despite this recognition, there has been no attempt to verify whether small and large software organizations implement software process improvement (SPI) programs differently in order to advance their businesses.This study examines whether an organization's size affects its SPI implementation strategy and the degree of SPI success. Based on an extensive literature review of critical factors of quality management, organizational learning, and SPI, a survey questionnaire was developed and data on the implementation of six organizational factors and the resulting organizational performance was collected through a mail survey of 120 software organizations. The findings show that small organizations reported that they implement SPI elements as effectively as large organizations, and in turn, achieve high organizational performance. The main lesson to be learned from this study is that to implement SPI at least as effectively as their large counterparts, small software organizations should capitalize on their relative strengths in employee participation and exploration of new knowledge.
Deadline analysis of interrupt-driven software
Authors: Brylow Dennis , Palsberg Jens
Published: July 2004

Real-time, reactive, and embedded systems are widely used throughout society (e.g., flight control, railway signaling, vehicle management, medical devices, and many others). For real-time, interrupt-driven software, timely interrupt handling is part of correctness. It is vital for software verification in such systems to check that all specified deadlines for interrupt handling will be met. Such verification is a daunting task because of the large number of different possible interrupt arrival scenarios. For example, for a Z86-based microcontroller, there can be up to six interrupt sources and each interrupt can arrive during any clock cycle. Verification of such systems has traditionally relied upon lengthy and tedious testing; even under the best of circumstances, testing is likely to cover only a fraction of the state space in interrupt-driven systems.This paper presents a tool for deadline analysis of interrupt-driven Z86-based software. The main idea is to use static analysis to significantly decrease the required testing effort by automatically identifying and isolating the segments of code that need the most testing. Our tool combines multi-resolution static analysis and testing oracles in such a way that only the oracles need to be verified by testing. Each oracle specifies the worst-case execution time from one program point to another, which is then used by the static analysis to improve precision. For six commercial microcontroller systems, our experiments show that a moderate number of testing oracles are sufficient to do precise deadline analysis.
Ontology support for web service processes
Authors: Pahl C. , Casey M.
Published: July 2004

Web Services are software services that can be advertised by providers and deployed by customers using Web technologies. This concept is currently carried further to address Web service choreography. Choreography refers to the composition of individual services to services processes that can communicate and interact with another.We propose a formal ontology framework for these Web service processes that supports the description, matching, and composition through logic reasoning techniques. The Semantic Web, based on a description logic-based knowledge representation and reasoning framework, provides the foundations. Integrating aspects from modal logics and process calculi into this framework will prove essential.
Differences between versions of UML diagrams
Authors: Ohst Dirk , Welle Michael , Kelter Udo
Published: July 2004

This paper addresses the problem of how to detect and visualise differences between versions of UML documents such as class or object diagrams. Our basic approach for showing the differences between two documents is to use a unified document which contains the common and specific parts of both base documents; the specific parts are highlighted. The main problems are (a) how to abstract from modifications done to the layout and other (document type-specific) details which are considered irrelevant; (b) how to deal with structural changes such as the shifting of an operation from one class to another; (c) how to reduce the amount of highlighted information. Our approach is based on the assumption that software documents are modelled in a fine-grained way, i.e. they are stored as syntax trees in XML files or in a repository system, and that the version management system supports fine-grained data. Our difference computation algorithm detects structural changes and enables their appropriate visualisation. Highlighting can be restricted on the basis of the types of the elements and on the basis of the revision history, e.g. only changes which occurred during a particular editing session are highlighted.
Towards scalable compositional analysis by refactoring design models
Authors: Cheng Yung-Pin , Young Michal , Huang Che-Ling , Pan Chia-Yi
Published: July 2004

Automated finite-state verification techniques have matured considerably in the past several years, but state-space explosion remains an obstacle to their use. Theoretical lower bounds on complexity imply that all of the techniques that have been developed to avoid or mitigate state-space explosion depend on models that are "well-formed" in some way, and will usually fail for other models. This further implies that, when analysis is applied to models derived from designs or implementations of actual software systems, a model of the system "as built" is unlikely to be suitable for automated analysis. In particular, compositional, hierarchical analysis (where state-space explosion is avoided by simplifying models of subsystems at several levels of abstraction) depend on the modular structure of the model to be analyzed. We describe how as-built finite-state models can be
refactored
for compositional state-space analysis, applying a series of transformations to produce an equivalent model whose structure exhibits suitable modularity. The process is supported by a parser which can parse a subset of Promela syntax and transform Promela code into refactored state graphs.
Verified systems by composition from verified components
Authors: Xie Fei , Browne James C.
Published: July 2004

This paper presents an approach to integration of model checking into component-based development of software systems. This approach assists in development of highly reliable component-based software systems and reduces the complexity of verifying these systems by utilizing their compositional structures. Temporal properties of a software component are specified, verified, and packaged with the component. Selection of a component for reuse considers not only its functionality but also its temporal properties. When a component is composed from other components, a property of the component is verified on an abstraction of the component. The abstraction is constructed from environment assumptions of the component and verified properties of its sub-components. A general component model that enables component verification is defined. Component verification is discussed in the context of the instantiation of the general component model on an Asynchronous Interleaving Message-passing computation model. This approach has been applied to improve reliability of instances of TinyOS, a component-based run-time system for networked sensors. A case study on TinyOS is included, which illustrates the applicability of this approach, the detection of a bug, and the reduction in model checking complexity.
Composing architectural styles from architectural primitives
Authors: Mehta Nikunj R. , Medvidovic Nenad
Published: July 2004

Architectural styles are named collections of constraints on configurations of architectural elements, and are believed to bring economies of scale in applying software architecture techniques to software development. Existing research on architectural styles provides little guidance for the systematic design and construction of architectural style elements. This paper proposes a framework, Alfa, for systematically and constructively composing "architectural primitives" to obtain elements of architectural styles. This is based on our observation that architectural styles share many underlying concepts that lead to architectural primitives. We have identified eight forms and nine functions as architectural primitives that reflect the syntactic and semantic characteristics of architectural styles and are expressive enough to compose their elements. Our approach is also illustrated using a familiar style -- pipe-and-filter.
Towards an engineering tool for implementing reusable distributed control systems
Authors: Thramboulidis Kleanthis C.
Published: July 2004

The IEC model for distributed control systems (DCSs) was adopted for the implementation of a new generation engineering tool. However, it was found that this approach does not exploit all the benefits of the object and component technologies. In this paper, we present the enhanced 4-layer architecture that proved to be very helpful in the identification of the key abstractions required for the design of the new generation of function block based engineering tools. Despite being IEC-compliant, the proposed approach introduces a number of extensions and modifications to the IEC-model to improve the development process. The Unified Modelling Language is exploited during the requirements phase of DCSs, but the use of the FB construct is confected during the design phase.
Use case-based testing of product lines
Authors: Bertolino Antonia , Gnesi Stefania
Published: July 2004

This paper presents PLUTO, a simple and intuitive methodology to manage the testing process of product lines, described as Product Lines Use Cases (PLUCs). PLUCs are an extension of the well-known Cockburn's Use Cases, a notation based on natural language descriptions of requirements. The proposed test methodology is based on the Category Partition method, and can be used to derive a generic Test Specification for the product line, and a set of relevant test scenarios for a customer specific application.
A simulation-based approach to software performance modeling
Authors: Balsamo Simonetta , Marzolla Moreno
Published: July 2004

Quantitative performance analysis of software systems should be integrated in the early stages of the development process. We propose a simulation-based performance modeling of software architectures specified in UML. We propose an algorithm for deriving a simulation model from annotated UML software architectures. We introduce the annotation for some UML diagrams, i.e., Use Case, Activity and Deployment diagrams, to describe system performance parameters. Then we show how to derive a process-oriented simulation model by automatically extracting information from the UML diagrams. Simulation provides performance results that are reported into the UML diagrams as tagged values. The proposed methodology has been implemented into a prototype tool called UML-?. The proposed methodology will be illustrated on a simple case study.
Making sense of runtime architecture for mobile phone software
Authors: Ran Alexander , Lencevicius Raimondas
Published: July 2004

Making sense of runtime architecture for mobile phone software.
A case for teaching program verification
Authors: Mili Ali
Published: July 2004

Because of its relevance to program analysis and, ultimately, to program synthesis, the area of formal verification of program correctness is an important part of the education of the programmer and the computer scientist. A case is presented in this paper to advocate the teaching of the formal verification of computer programs. This case is based on three major arguments:

- The Why, i.e. the need for including a course on program verification in the computer science curriculum,

- The What, i.e. the technical contents of such a course as highlighted by the current state of the art,

- The How, i.e. the logistic feasibility of such a course within a fifteen-week semester.
A realistic, two-course sequence in large scale software engineering
Authors: Bolz Richard E. , Jones Lawrence G.
Published: July 2004

We discuss a two semester, senior level sequence of courses in large scale software development. The courses are keyed upon the element of realism by having an actual user supply an actual project. In the first course students develop a functional specification of user needs. In the second course students design a system from the specifications and implement at least a portion of the project. We discuss the significant benefits of having a real project and point to some drawbacks. We conclude by discussing possible applicability of our courses to other schools.
A project for a course in operating systems
Authors: Shub Charles M.
Published: July 2004

A simulated machine approach to an operating systems course project is described. The motivations for including the project in the course are delineated. The reasons for selecting the particular type of project are given. The fictitious hardware and the requirements for its simulation are presented. The conceptual issues are amplified. The methodology for a high level process oriented design for a multiprogrammed batch environment is delineated. The primitives to be used in the design are described and motivated. The issues to be addressed in the actual implementation of the paper design are explored. Possible extensions to the project are suggested. Student feedback is presented. Conclusions are drawn.