bluuebunny/crossref_metadata_2025 huggingface dataset:
How shall we assess this?
Authors: Carter Janet , Ala-Mutka Kirsti , Fuller Ursula , Dick Martin , English John , Fone William , Sheard Judy
Published: July 2004

Increased class sizes are forcing academics to reconsider approaches to setting and marking assessments for their students. Distributed and distance learning are creating some of the biggest changes. Some educators are embracing new technologies but others are more wary of what they do not know. In order to address this issue it is first necessary to investigate the types of assessment currently in use and the perceptions that are held by academics with and without experience of the new technologies that are becoming available.In this paper we present the findings of an international survey of Computer Science academics teaching a variety of topics within the discipline. The findings are split into two sections: a snapshot of current assessment practices and an analysis of respondents' perceptions of Computer Aided Assessment (CAA). Academics' opinions about the advantages and disadvantages of CAA are split in line with level of experience of using such techniques. Those with no experience of CAA suggest that it cannot be used to test higher-order learning outcomes and that the quality of the immediate feedback is poor; these negative opinions diminish as experience is gained.
Case studies in admissions to and early performance in computer science degrees
Authors: Alexander Sylvia , Clark Martyn , Loose Ken , Amillo June , Daniels Mats , Boyle Roger , Laxer Cary , Shinners-Kennedy Dermot
Published: July 2004

We present seven case-studies of undergraduate recruitment to Computer Science courses together with analysis of students' success during the early part of their study. We focus particularly upon qualification on entry, the subjects studied in the early university curriculum, and student grades.We find that while university admissions are complex processes, there exists sufficient commonality to permit some useful comparisons. These suggest that predicting undergraduate performance on the basis of entry qualifications is fraught. Nevertheless, it seems that students who arrive at university with a record of success in earlier studies may be more likely to succeed than otherwise. In particular, good grades in pre-university study may indicate that they are more likely to do well in the mathematical part of the university curriculum. Conversely, we find nothing in entry qualifications to indicate which students will be successful in the study of programming.
MUSE studio lab and innovative software engineering capstone project experience
Authors: Ramakrishan Sita
Published: July 2004

This paper presents our rationale in setting up an innovative studio lab called the MUSE (Monash University Software Engineering) Studio Lab for our final year undergraduate Software Engineering students in 2002, an evaluation of the outcomes for 2002 and plans for 2003 and beyond. We describe the Monash University Software Engineering (MUSE) Strategy to make the MUSE culture and MUSE agile process branding visible through the MUSE Studio Lab for the learners, academics, management and the outside world of academia and industry. This strategy is aimed at supporting a continuum of learning styles in three units in the final year of our Bachelor of Software Engineering Program. The teaching/learning model used is a predominantly constructivist/student-centered/active learning approach for the Capstone SE project (Studio unit), and a constructivist approach for the Honours Research thesis unit. A more traditional teaching approach is used for the Systems Validation, Verification, Quality & Standards unit based on traditional instructional design model which is objectivist in view of learning. We also provide details of the the middle weight process that student groups follow in their full year SE Capstone project. At MUSE Studio, we have fused pedagogy with technology.
Integrating a simulation-visualisation environment in a basic distributed systems course
Authors: Koldehofe Boris , Papatriantafilou Marina , Tsigas Philippas
Published: July 2004

Distributed algorithms can be difficult to understand as well as to teach. A way to provide students with an experience of the execution of a distributed algorithm is the use of a simulation-visualisation environment. In this work we present a case study of integrating a simulation-visualisation environment into a distributed system course. We evaluate a distributed system assignment in which students used LYDIAN, an extensible library for distributed algorithms and animations, to implement their algorithms. In our study neither the teachers nor the students had earlier class experience with LYDIAN. The feedback received gives valuable information on what simulation-visualisation environments for distributed algorithms need to provide in order to be successfully used in class. We are not aware of any similar study in the area of distributed computing. However, the feedback we have received shows the significance of such evaluations to help users improve their performance and help them to acknowledge the wealth of tools they are provided.
Influences on cheating practice of graduate students in IT courses
Authors: Sheard Judy , Dick Martin
Published: July 2004

This paper presents an analysis of results of a survey of graduate students in IT courses that aimed to gain an understanding of their views of cheating and knowledge of their cheating practice. The survey was part of an investigation into the cheating behaviour of IT students within the Faculty of Information Technology of Monash University. Using a factor analysis technique, categories of cheating behaviour and categories of reasons that could cause cheating or prevent cheating were identified. These were then used to determine possible influences on different types of cheating behaviour. A search of the literature has shown that there is a scarcity of studies of cheating behaviour of IT students, especially at the graduate level. The results of this study are informing an education program and development of policy on student cheating within our Faculty.
Equilibriating instructional media for cognitive styles
Authors: Redmond James A. , Walsh Cathal , Parkinson Adrian
Published: July 2004

Two types of instructional (Text and Web) that had been used in a previous study [1] were adapted to accommodate Cognitive Style preferences for Witkin's Field-dependent [2] and Riding's Imager [3]. Ninety six Information Systems students were randomly allocated to each of these environments and their Cognitive Styles were assessed. The students studied an Introductory Course in Artificial Intelligence one hour per week for six weeks after which they were assessed by a one hour exam. It was found that Field-dependents and Field-independents performed similarly in both environments as indicated by their examination scores demonstrating the success of the adaption of both environments for Field-dependents. The adaptation for Imagers as measured by Riding's CSA [3] was not successful as Verbalisers performed better than Imagers in both Text and Web. This raises questions about the stability of Riding's Verbaliser/Imager dimension. People performed significantly better in the Text environment than in the Web environment.
Incorporating quality assurance processes into requirements analysis education
Authors: Moody Daniel L. , Sindre Guttorm
Published: July 2004

The traditional thrust of software quality assurance has been to use "brute force" testing at the end of development. However quality assurance in the early phases of development is an order of magnitude more cost effective than testing done at the end of development. This paper describes the introduction of quality reviews as a learning activity into an undergraduate requirements analysis course, and evaluates the effectiveness of this in improving learning. In the absence of any standard instrument for evaluating learning effectiveness, we developed a survey instrument called the Learning Effectiveness Survey. Using this instrument, learning effectiveness is evaluated in the context of the learning goals of the course (short term learning), and in the context of the broader educational programme and future working life (long term learning). It also provides feedback on the learning intervention and how it can be improved. While the intervention was moderately successful in its first application, a great deal was learned about how it could be improved next time.
Objects
Authors: Dann Wanda , Dragon Toby , Cooper Stephen , Dietzler Kevin , Ryan Kathleen , Pausch Randy
Published: July 2004

Animated program visualization can be used to support innovative instructional methods for teaching beginners about objects, their behavior, and state. In this paper, we present a discussion of methods that define object behavior and character (class)-level state variables that track state changes for 3D animated objects in small virtual worlds. We have found that character-level methods provide a means to demonstrate inheritance. Examples of worlds and program code used in instructional materials are provided.
Embryonic object versus mature object
Authors: Rasala Richard
Published: July 2004

Traditional approaches to object-oriented style emphasize classes with a basic set of constructors and a minimal set of methods that when combined permit the full potential of the instance objects to be realized. This object-oriented style is probably modeled on the style used in mathematics and logic to develop a system based on a minimal set of axioms and operations. The consequences of this style both in practice and in pedagogy are that objects enter into existence in an
embryonic
state and must be nurtured to
maturity
by a sequence of method calls that tweak behavior and/or add data. Although this minimalist approach is useful in the first stages of teaching objects and in exploratory design, we suggest that
most designs should evolve towards building classes with a rich set of constructors and methods
so that the instance objects may be
born mature
, that is, ready to use in the program without further tweaking. In particular, we believe that if students are taught to design in this manner, then they will be more effective both as students and as computing professionals.The ideas in this article have developed from our experience in designing the Java Power Tools (JPT) and in applying these tools to build many labs and demo programs. We found that using the traditional minimalist design approach hindered our ability to rapidly develop interesting applications. Gradually, we evolved both the tools and the examples to be far richer and have found that our development time has been dramatically reduced. We believe that those who teach objects may be interested in these principles even if they choose to work with entirely different tools and examples.
Classroom discussions
Authors: Granger Mary J. , Little Joyce Currie
Published: July 2004

Since the early to mid 1990s, with the advent of easy to use browser software, the Internet has become available to those outside the community of researchers and knowledgeable users. Currently, anyone with computing and some type of networking capability is able to connect to the internet: some still through University and work-place links, others through internet Service Providers (ISPs). For their customers, these ISP provide an entry point into the Internet and may control or monitor activities on the Internet. Additionally, since the Internet is an international network, it should not be overlooked that some governments control access or the ISPs, which presents a different set of issues than those encountered in the United States. The purpose of this paper is to raise awareness of policies and responsibilities of Internet Service Providers related to usage of the Internet. It is suggested that these issues be incorporated in classroom discussions. Some of the topics which may be explored by using ISPs policies in an educational setting are intellectual property concerns, 'cookies,' third party sites and access, collection of personal information - what, how and usage, security of information, regulation of children's access to the Internet, globalization issues and legal issues arising with the use of an ISP to access the Internet.
Repositories for CS courses
Authors: Jones Edward L. , Allen Clement S.
Published: July 2004

This paper describes a simple Unix-based repository that supports programming intensive courses. Initially motivated by the need to capture sample artifacts for the capstone course sequence, the repository has evolved to support progam submission, on-line testing, and automated program grading. Repository features enforce naming conventions, assignment due dates, while supporting the use of Unix in programming classes. The repository also facilitates consistent on-line program compilation and execution. Repository utilities are provided to support first-time adoption, for archiving repositories from past terms, and for establishing repositories for a new academic term. Results from the transfer of the technology to first-time adopters are presented.
Structuring CSed research studies
Authors: Pears Arnold N. , Daniels Mats
Published: July 2004

Changing conditions for teaching increase our motivation to understand the teaching and learning process. First time investigators of educational settings often feel uncertain about what aspects are involved and how to design a meaningful investigation. This paper develops and describes an applied research model with the objective of providing computer science (CS) academics of with a structured overview of the inter-disciplinary research components of CS education research.The paper argues that adopting such a model has the potential to enhance the maturity, significance and applicability of CS education research studies by placing them in a more complete research context. This helps to make the outcomes more readily transportable to other teaching and learning situations.One aim of publicizing the model is to help inspire the growing numbers of people who are becoming interested in CS education research. In addition we hope to simplify the task of gaining a rapid understanding of the research design issues and options that are typically involved.
Peer-to-peer learning with open-ended writable Web
Authors: Kurhila Jakko , Miettinen Miikka , Nokelainen Petri , Floréen Patrik , Tirri Henry
Published: July 2004

In spite of advances in educational technology, most Web-based computer science courses rely on costly pre-made learning materials. By shifting the emphasis to peer-to-peer learning and other student-centred learning principles, more meaningful learning process can be accomplished, without preparing stand-alone Web-courses. A course applying these principles is presented along with a tool built for the purpose. The tool offers the possibility to build a joint information pool and publish new work while constructing knowledge by collaborative annotation of the information or published work. According to our experince, transparency in the learning process is also well-accepted and viewed beneficial by the students.
Computer science students' conception of the relationship between reward (grade) and cooperation
Authors: Hazzan Orit
Published: July 2004

The study presented in this article focuses on the conceptions of computer sciences students of the relationships between reward and cooperation in the context of software development. Specifically, students were faced with a conflict between their urge to express personal skills, and the unavoidable need to cooperate with their teammates. The results indicate that if a given financial bonus is distributed among team members, the majority of the students prefer that a small portion of the bonus be allocated based on individual contributions, while the majority of the reward is divided equally among the team members. These result are analyzed in the context of software engineering education. Based on this study, this paper suggests a tool which can be used by instructors, both for forming of teams and for team evaluation.
Integrating usability engineering into the computer science curriculum
Authors: Rozanski Evelyn P. , Schaller Nan C.
Published: July 2004

The authors propose a model for incorporating usability engineering into the undergraduate computer science curriculum using an example curriculum from an accredited undergraduate computer science program in the United States. This model proposes that human-computer interaction and usability engineering concepts be integrated throughout the computer science curriculum rather than treated as disjoint topics.
An undergraduate track in computer security
Authors: Azadegan S. , Lavine M. , O'Leary M. , Wijesinha A. , Zimand M.
Published: July 2004

To better prepare our graduates to face the challenges in computer and information security, in Fall 2002, Towson University launched an undergraduate track in computer security for the computer science majors. This paper describes the motivation behind this track and discusses its structure and requirements.
Development of a MLE by students for students using extreme programming techniques
Authors: Holloway Jonathan , Ratcliffe Mark
Published: July 2004

This paper describes the approach taken to develop Tweek; a student centered learning environment; an environment that supports learning in the real sense of the word.
The stepping stones project
Authors: Bentley Hilary , Davies Dr Jenny , Allan Dr Jo
Published: July 2004

Widening participation in higher education institutions is bringing about major changes to the student profile. New universities, especially, have found that a higher proportion of students now come from non-traditional backgrounds. Since there is seen to be a correlation between increasing access to students from non-traditional backgrounds and higher drop-out rates [1] this trend presents problems in terms of achievement, progression and retention.Meeting the diverse needs of students will accelerate changes already underway to enhance teaching and learning in universities, but there are obstacles, particularly the reluctance to bring about changes to the curriculum design and delivery in case standards should become diluted.In line with results obtained nationally, statistical examination of our first-year database showed that students with a GNVQ background had an enhanced risk of non-completion. The learning styles and strategies adopted by students and the particular further education institution where they previously studied are also thought to be influential in determining a student's chance of success. It is therefore vital that changes to curriculum, delivery, assessment and support are underpinned by detailed knowledge of the approaches to learning adopted by our students, and those factors which enable and encourage students to adopt a deep approach to learning, since a student's approach to a given learning activitiy depends upon his or her perception of the requirements of the task [2].A longitudinal study is underway to investigate the influence of entrance qualification, feeder institution, learning styles and achievement at level one. The research aims to enable early detection of students at risk of being unsuccessful and to identify the factors within the further education environment that lead to successful learning in higher education. The poster will outline the underlying issues, the rationale and the approach being taken.
Computer science and the arts
Authors: Parker J. R. , Becker Katrin , McCullough Douglas
Published: July 2004

We explain the need for formal collaboration between students in the arts and computer science students, and argue that this should be encouraged at an early stage of their education. Two specific courses that foster this sort of cooperation are described.
Teaching graphical interface programming in Java with the game of wari
Authors: Scott Kirk
Published: July 2004

This poster gives an overview of a programming project that can be used in a course on object-orientation and graphical interface programming in Java.
Student status monitoring tool (SSM)
Authors: Darbhamulla Ravikumar , Das Manirupa , Lawhead Pamela
Published: July 2004

Distance Education has entered a new era, where it is now possible for courseware to be delivered online in a very effective, efficient and appealing manner. At the Institute for Advanced Education in GeoSpatial Science (IAESG), a project funded by NASA, it is our objective to develop a repository of dynamic online coursework in the field of Geospatial Information Technology. These courses are intended to enhance the traditional university learning through visually rich content, and also through closely emulating the concept of an Expert in a virtual environment. It thus becomes imperative to address a number of pedagogical issues in the design of such a dynamic web-based course delivery system. Traditional education generally involves two main entities: an Expert, and some form of reference material such as a textbook. The Expert imparts knowledge interactively in the real world, and is in some sense the more 'active' or 'intelligent' agent, whereas the textbook is just reference since it has limited scope, and hence is the 'passive' or 'static' agent. Thus the pedagogical issue that needs the most immediate attention, while dealing with learner-centered online course delivery is the issue of how to emulate the real-world Expert in a virtual learning environment. We realize that the role, the Expert plays in knowledge transfer is multi-faceted. One of the roles of the Export is to use traditional testing methodologies like quizzes and exercise to evaluate the performance of a learner. In an online environment, the best way to achieve this continous evaluation is to get constant feedback on the performance and learning style of the student, via 'Student Status Monitoring' (SSM) tool. The research we present focuses on this pivotal aspect of effective online learning.
Using an education oriented digital library to organize and present classes in computing and information
Authors: Cassel Lillian N. , Impagliazzo John , Knox Deborah , Giles C. Lee , Fox Edward A. , Lee JAN , Pérez-Quiñones Manuel A.
Published: July 2004

This demonstration allows conference attendees to gain experience in using the facilities of the NSF National Science Technology Engineering and Mathematics Education Digital Library (NSDL) to prepare and present College or university level classes.
Studying program correctness in ProVIDE
Authors: Gegg-Harrison Timothy S. , Bunce Gary R. , Ganetzky Rebecca D. , Olson Christina M. , Wilson Joshua D.
Published: July 2004

In an attempt to better integrate discrete mathematics into the introductory CS curriculum, we implemented ProVIDE, an enhanced integrated development environment (IDE) for Java that enables students to analyze their computer programs (in terms of their correctness) while they are creating them [1]. The primary goal of the construction of ProVIDE is the seamless integration of analysis with the creation of computer programs. Because the concept of program correctness is generally taught as an activity independent of the programming process, most introductory CS students preceive it is 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.The approach we have taken with ProVIDE is a modified version of the "design by contract" methodology. Rather than asking the student programmer 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.In this demonstration, we will show some examples of method precondition construction (including loop invariant construction) within ProVIDE, including the following squaring algorithms that uses only additions (which highlights the construction of a loop invariant for a single loop) and only increments and decrements (which highlights the construction of loop invariants for both sequential and nested loops), respectively.
Rapid evaluation using multiple choice tests and TeX
Authors: Sojka Petr
Published: July 2004

This paper describes a framework for effective design, typesetting, use and evaluation of students that uses multiple-choice tests. With this approach, based on a T
E
X engine, macros and a small program, several hundred customized tests can be typeset, printed and evaluated within several hours, allowing significant savings of educator's time and rapid electronic dissemination of tests results.
Teaching Java
Authors: Paterson James H. , Haddow John
Published: July 2004

In this Tip we describe the use of a simple Object Oriented database system to implement object persistence in Java programming projects.
Using ToolBook authoring tool to facilitate the teaching of algorithms
Authors: Papadopoulos George , Polatoglou Hariton M.
Published: July 2004

An application is developed and used in teaching the subject of algorithms. It is used in classroom practice, at Lyceum and the University. The results show that the application increased students interest, helped the students to realize the importance of the algorithums and their workings, and grasp some abstract computer science concepts.
Report from the ICSE workshop
Authors: Kazman Rick
Published: July 2004

The First International Workshop on the Relationships between Software Engineering and Human-Computer Interaction was held on May 3--4, 2003 as part of the 2003 International Conference on Software Engineering, in Portland, OR, U.S.A. This workshop was motivated by a perception among researchers, practitioners, and educators that the fields of Human-Computer Interaction and Software Engineering were largely ignoring each other and that they needed to work together more closely and to understand each other better. This report describes the motivation, goals, organization, and outputs of the workshop and the significant activity that it has subsequently fostered.
ICSE 2003 workshop on software architectures for dependable systems
Authors: de Lemos Rogério , Gacek Cristina , Romanovsky Alexander
Published: July 2004

This workshop summary gives a brief overview of a one-day Workshop on "Software Architectures for Dependable Systems" held in conjunction with ICSE 2003.
Errors in the UML metamodel?
Authors: Fuentes José M. , Quintana Víctor , Llorens Juan , Génova Gonzalo , Prieto-Díaz Rubén
Published: July 2004

The Unified Modeling Language (UML) is becoming a standard for software specification, verification, visualization and documentation. Using the rules provided by the standard, software engineers can create models that are concrete and unambiguous.UML creators Booch, Rumbaugh and Jacobson, have defined the standard using UML terminology: they use model elements to define the standard. This way of representing UML is called UML Metamodel, and it is publicly available along with the English definition of the standard.The UML metamodel is intended for software engineers to verify the correctness of their models. It should be assumed, therefore, that the UML metamodel is itself error free. A close study of the UML metamodel by the authors, however, has shown that this may not be the case.After checking the Metamodel with all the rules, constraints and well-formedness rules defined by the standard, the authors found 450 errors and classified them in three different groups:1.
Non-accessible elements
: represents the most important problem found in the metamodel, and involves some misunderstandings with the
contents
method.2.
Empty names
: some rules of the standard states that some elements could not have the same name. Nevertheless, the standard does not clarify whether there could exist two different elements without name, which could be considered as the same (empty) name.3.
Miscellanea
: this last group of problems deals with duplicated names and derived associations.This paper analyzes and explains the reason for the errors and presents some suggestions for correcting, what the authors believe, are some deficiencies in UML's current standard. The analysis presented should be valuable to practicing software engineers engaged in software modeling.
Component-based measurement
Authors: Gill N. S. , Grover P. S.
Published: July 2004

Software industries are striving for new techniques and approaches that could improve software developer productivity, reduce time-to-market, deliver excellent performance and produce systems that are flexible, scalable, secure, and robust. Only software components can meet these demands and following this; component-based software engineering (CBSE) has emerged, which has generated tremendous interest in software development community. The paradigm shift to software components appears inevitable, necessitating drastic changes to current software development and business practices. The scope of this paper is to suggest few necessary guidelines for deriving component-based metrics. The paper discusses issues related to component-based development (CBD) and suggests a general definition of software component based on several existing definitions. Further, the paper outlines the necessity of component measurement and also discusses the limitations of traditional software metrics for component-based development (CBD) systems. Finally, this paper also suggest few necessary guidelines for CBD measurement and proposes some relevant metrics applicable to CBD systems, which after proper quantification and validation may help guiding risk and quality management of component-based systems.
The effects of individual XP practices on software development effort
Authors: Kuppuswami S. , Vivekanandan K. , Ramaswamy Prakash , Rodrigues Paul
Published: July 2004

Traditional
heavyweight
software development methodologies are rigid, heavily documentation oriented and process oriented. In the present E-Business dominated environment, the above methodologies are hard to follow. In response to this, a new generation of lightweight methodologies such as Extreme Programming (XP) has evolved which has only a few simple rules to adopt, and insist on less documentation. XP proposes four values, a development process and twelve practices. One of the significant benefits among those claimed by the inventors of XP is the
reduction of effort in the software development
. However, the extent of fulfillment of this claim remains unanswered by empirical and quantitative evidences. Hence, the effects of XP on software development effort are to be investigated. In this study, we developed a process simulation model to analyze the effects of individual XP practices on development effort. System dynamics based simulation, an effective modeling technique for software development process was chosen. This model has accounted for all the twelve practices and processes of XP. We have also introduced a measurement scale for measuring the level of usage of individual XP practices. The factors that affect the cost are collected from literature and a few XP project managers. The
process model
was simulated for a case study of a typical XP project to investigate the effects of individual XP practices on development effort by varying their usage levels. The decrease in percentage of the development effort for each XP practice when its usage level is varied from minimum to maximum during which all the other practices were maintained at a constant usage level was found. The decrease in percentage of the development effort for each XP practice when its usage level is minimum and maximum was computed and is given below. (i) Planning game - 2.67% (ii) Small Release - 2.67% (iii) Metaphor - 2.01% (iv) Simple design - 2.5% (v) Continuous Testing - 2.88% (vi) Refactoring -0.677% (vii) On-site Customer - 5.48% (viii) Pair programming - 4.4% (ix) Collective Code Ownership -- 4.82% (x) Forty Hours Per Week - 2% (xi) Coding Standard - 4.82% (xii) Continuous Integration - 1.13%. The finding of the present study on the effects of individual XP practices depicts a reduction in software development effort by enhancing their usage levels.
Estimating the CPU utilization of a rule-based system
Authors: Avritzer Alberto , Ros Johannes P. , Weyuker Elaine J.
Published: July 2004

Rule-based software systems have become very common in telecommunications settings, particularly to monitor and control workflow management of large networks. At the same time, shorter deployment cycles are frequently necessary which has led to modifications being made to the rule base, without a full assessment of the impact of these new rules through extensive performance testing.An approach is presented that helps assess the performance of rule-based systems, in terms of its CPU utilization, by using modeling and analysis. A case study is presented applying this approach to a large rule-based system that is used to monitor a very large industrial telecommunications network.
Software performance modelling using PEPA nets
Authors: Gilmore Stephen , Hillston Jane , Kloul Leïla , Ribaudo Marina
Published: July 2004

Modelling and analysing distributed and mobile software systems is a challenging task. PEPA nets---coloured stochastic Petri nets---are a recently introduced modelling formalism which clearly capture important features such as location, synchronisation and message passing. In this paper we describe PEPA nets and the newly-developed platform support for software performance modelling using them. Crucial to this support is the compilation from PEPA nets into Hillston's PEPA stochastic process algebra in order to access the software tools which support the PEPA algebra. In addition to derivation of steady state performance measures, this suite of tools allows properties of the system to be verified using model-checking. We show the application of PEPA nets in the modelling and analysis of a secure Web service.
Performance lies my professor told me
Authors: Dugan Robert F.
Published: July 2004

In this paper we report a survey examining the approach to performance and software engineering in courses at highly ranked computer science schools in the United States. An analysis of the survey shows serious shortcomings including inadequate or missing definitions of performance, reactive "fix it later" mentality, vague performance requirements, and a general lack of awareness of the practices developed by the Software Performance Engineering (SPE) community. The survey is followed by guidelines for teaching SPE to undergraduates based on a semester long course we have developed. It is our plan to incorporate these guidelines into the curriculum of our senior capstone software engineering course.
Application performance on the Direct Access File System
Authors: Fedorova Alexandra , Seltzer Margo , Magoutis Kostas , Addetia Salimah
Published: July 2004

The Direct Access File System (DAFS) is a distributed file system built on top of direct-access transports (DAT). Direct-access transports are characterized by using remote direct memory access (RDMA) for data transfer and user-level networking. The motivation behind the DAT-enabled distributed file system architecture is the reduction of the CPU overhead on the I/O data path.We have created an implementation of DAFS for the FreeBSD platform. In this paper we describe the performance evaluation study of DAFS that we have performed using this software. The goal of this study is to determine whether the architecture of DAFS brings any fundamental performance benefits to applications compared to traditional distributed file systems, such as NFS. We perform comparison of DAFS to a version of NFS optimized to reduce the I/O overhead. In order to thoroughly understand the impact of DAFS on application performance, we consider a diverse range of applications workloads.We conclude that DAFS can accomplish superior performance for latency-sensitive applications, outperforming NFS by up to a factor of 2. Bandwidth-sensitive applications do equally well on both systems, unless they are CPU-intensive, in which case they perform better on DAFS. We also found that RDMA is a less restrictive mechanism to achieve copy avoidance than that used by the optimized NFS.
Early performance testing of distributed software applications
Authors: Denaro Giovanni , Polini Andrea , Emmerich Wolfgang
Published: July 2004

Performance characteristics, such as response time, through put and scalability, are key quality attributes of distributed applications. Current practice, however, rarely applies systematic techniques to evaluate performance characteristics. We argue that evaluation of performance is particularly crucial in early development stages, when important architectural choices are made. At first glance, this contradicts the use of testing techniques, which are usually applied towards the end of a project. In this paper, we assume that many distributed systems are built with middleware technologies, such as the Java 2 Enterprise Edition (J2EE) or the Common Object Request Broker Architecture (CORBA). These provide services and facilities whose implementations are available when architectures are defined. We also note that it is the middleware functionality, such as transaction and persistence services, remote communication primitives and threading policy primitives, that dominate distributed system performance Drawing on these observations, this paper presents a novel approach to performance testing of distributed applications. We propose to derive application-specific test cases from architecture designs so that performance of a distributed application can be tested using the middleware software at early stages of a development process. We report empirical results that support the viability of the approach.
Early-stage performance modeling and its application for integrated embedded control software design
Authors: Wang Shige , Shin Kang G.
Published: July 2004

Most of current embedded control software (ECSW) development techniques deal only with performance specifications during the early software design phase and delay the modeling and analysis until the detail design has been completed. In this paper, we propose a new approach to modeling and analysis of the performance of the designed ECSW without knowing the platform configuration and the software deployment. The functional model is assumed --- as is commonly the case in practice --- to be constructed by integrating existing (reusable) software components. The performance of components and connections in the model are modeled using annotated requirements and virtual resource demands. Our algorithm then computes the system performance such as end-to-end delays of transactions and workloads by traversing the model. The results can be applied to the platform design and runtime architecture generation. To demonstrate the usefulness of the proposed method in real world applications, we present the analysis of automotive vehicle-to-vehicle control software as an example.
Experimenting different software architectures performance techniques
Authors: Balsamo Simonetta , Marzolla Moreno , Di Marco Antinisca , Inverardi Paola
Published: July 2004

In this paper we describe our experience in performance analysis of the software architecture of the NICE ease study which is responsible for providing several secure communications in a naval communication system. We applied two complementary techniques, one based on stochastic process algebras and one based on simulation, in order to derive some performance indices at the software architectural level. The case study analysis allows us to point out the relative merit of the considered techniques including the performance model derivation, the type of analysis and performance results that we can carry out, and the feedback at the design level, e.g. performance results interpretation that we obtain. Finally, we discuss how to take advantage of the integration of different techniques in software architecture performance analysis.
Incorporating SPE into MDA
Authors: Verdickt Tom , Dhoedt Bart , Gielen Frank
Published: July 2004

A typical feature of a distributed system is the heterogeneity of its components (their geographical spreading, using different programming languages and platform architectures, etc.). To solve some of the problems related to this heterogeneity, many distributed systems use communication middleware.This paper presents an MDA model transformation algorithm and tool for transforming a high-level Platform Specific Model (high-level PSM) to a low-level PSM by including the structural changes and the overhead of using CORBA as a middleware. The resulting PSM (a UML model annotated with performance information, using the UML performance profile) can be used for generating performance models of the system, using existing methods and tools.
Profiling Java applications using code hotswapping and dynamic call graph revelation
Authors: Dmitriev Mikhail
Published: July 2004

Instrumentation-based profiling has many advantages and one serious disadvantage: usually high performance overhead. This overhead can be substantially reduced if only a small part of the target application (for example, one that has previously been identified as a performance bottleneck) is instrumented, while the rest of the application code continues to run at full speed. The value of such a profiling technology would increase further if the code could be instrumented and de-instrumented as many times as needed at run time.In this paper we present an experimental profiling system called JFluid, which includes a modified Java™ VM and a GUI tool, and addresses both of the above issues. Our tool supports instrumentation of a group of methods defined as an arbitrary "root" method plus all methods that it calls (a call subgraph). It appears that static determination of all methods in a call subgraph is difficult in presence of virtual methods, bug fortunately, with dynamic code hotswapping available, two schemes of
dynamic
call subgraph revelation and instrumentation can be suggested. Measurements that we obtained when performing full and partial program profiling using both schemes show that the overhead can be reduced substantially using this technique, and that one of the schemes generally results in a smaller number of instrumented methods and better performance. Furthermore, we observe that our approach generally works much better for large (for example, J2EE and Web) applications, than for small benchmarks.
Validated observation and reporting of microscopic performance using Pentium II counter facilities
Authors: Najafzadeh Haleh , Chaiken Seth
Published: July 2004

Microprocessors typically have software readable counters for events such as instruction executions, cycles, instruction stalls, and cache misses. Besides their usefulness to report overall performance metrics, these counters reveal details about dynamic process behavior and hardware affects of compiler optimizations. Our research develops and evaluates, in case studies, methodologies to determine just how accurate measurements from counters can be. We might then compensate for, reduce and/or estimate errors caused by the instrumentation or by system activity unrelated to the phenomena under study. We validate our flow-graph based perturbation model on small cases using static instruction counting, basic cache theory, and interrupt vs. cycle frequencies. We validate on larger cases using the existing Linux system calls, shells and user mode hardware counter access instructions. Our studies indicate so far that these performance factors, as related to specific machine code and data organization, can be directly observed in a practical/working system (Linux) with reasonable accuracy and that they can be quantitatively related to measurements of overall performance. Our current focus is on microscopic observations and phenomena because we seek to fully understand the capabilities and limitations of software accessible hardware self-reporting features of recent (Pentium II) technology.
Predicting the performance of middleware-based applications at the design level
Authors: Liu Yan , Fekete Alan , Gorton Ian
Published: July 2004

In this paper, we present an approach to predict the performance of middleware-based applications at the design level. We develop a quantitative performance model for a proposed system design. The inputs needed to produce this performance prediction are a state diagram showing the main waiting and resource usage aspects of the proposed system architecture, and measurements taken on the middleware infrastructure using a simple benchmark application which is much cheaper to implement than the full system. The performance model allows the system designer to evaluate the architecture and implementation approaches in term of their ability to achieve required performance. We show our method in action using a J2EE application, Stock-Online, and validate the predictions by implementing the design and measuring its performance. The modeling approach is applicable to applications built on common middleware technologies such as CORBA, J2EE and COM+/.NET.
A framework for QoS-aware software components
Authors: Menascé Daniel A. , Ruan Honglei , Gomaa Hassan
Published: July 2004

The next generation of software systems will be highly distributed, component-based, service-oriented, will need to operate in unattended mode and possibly in hostile environments, will be composed of a large number of "replaceable" components discoverable at run-time, and will have to run on a multitude of unknown and heterogeneous hardware and network platforms. This paper focuses on service oriented-architectures in which each component provides a set of interrelated services to other components. These components are QoS-aware (i.e., aware of Quality of Service requirements) and are capable of engaging in QoS negotiations with other components of a distributed application. The main contributions of this paper are: i) the description of an architecture for QoS-aware software components that are able to negotiate QoS requirements with other components, ii) the specification of the protocols used for QoS negotiation and admission control at the QoS-aware components, iii) a report on the implementation of a QoS-aware component, and iv) the experimental validation of the ideas presented in the paper.
Towards a UML profile for QoS
Authors: Cortellessa Vittorio , Pompei Antonio
Published: July 2004

Non-functional attributes of software/hardware systems are aspects of interest to embed in modeling notations. In the last few years, extensions of UML in this direction have been proposed, and some of them have been recently adopted as final specifications, such as the UML Profile for Schedulability, Performance, and Time. In this paper we intend to further contribute to the integration of UML with non-functional aspects, and we devise a lightweight extension of UML (i.e., stereotypes, tagged values and constraints) to represent issues related to the reliability modeling of component-based systems. To a certain extent we lay on other profiles to make easier the embedding of such issues and to work toward a unifying UML profile for Quality of Service and Fault Tolerance. Our extensions mostly concern the fault forecasting task, which enables the specification of models describing the failure rates of components and combines them to obtain a reliability factor for the whole system. Example diagrams from an elevator system help to show how the concepts introduced here can be used to design reliability-integrated UML models of component-based systems. In order to demonstrate the practical benefits of our approach we also show how to fit the proposed tagged values into a reliability model.