Showing papers on "User story published in 2003"

The user–developer communication process: a critical case study

Abstract: .Although user participation in systems development is widely believed to have positive impacts on user acceptance, it does not guarantee success and there is still much that we do not know about how and why user participation sometimes delivers positive benefits, but not always. Much of the prior research on user participation assumes that user–developer communication will ensure that the resulting system will be designed to meet users’ needs and will be accepted by them. The nature and quality of the communication between users and developers, however, remains an understudied aspect of user participation. In this paper, we focus on the user–developer communication process. We propose a process model that delineates four stages of communication between users and software developers, and we argue that these stages must occur for user participation to lead to effective outcomes. To illustrate our model, we apply it to analyse a ‘critical case study’ of a software project that failed despite high levels of user involvement. We show that when ‘communication lapses’ occurred in several of the user–developer communication stages, developers failed to be informed regarding the underlying reasons that users avoided the system. Based on the insights from this case study, we advise researchers and practitioners how to leverage the potential benefits of user participation, rather than take them for granted.

A Movie Recommendation System—An Application of Voting Theory in User Modeling

Abstract: Our research agenda focuses on building software agents that can employ user modeling techniques to facilitate information access and management tasks. Personal assistant agents embody a clearly beneficial application of intelligent agent technology. A particular kind of assistant agents, recommender systems, can be used to recommend items of interest to users. To be successful, such systems should be able to model and reason with user preferences for items in the application domain. Our primary concern is to develop a reasoning procedure that can meaningfully and systematically tradeoff between user preferences. We have adapted mechanisms from voting theory that have desirable guarantees regarding the recommendations generated from stored preferences. To demonstrate the applicability of our technique, we have developed a movie recommender system that caters to the interests of users. We present issues and initial results based on experimental data of our research that employs voting theory for user modeling, focusing on issues that are especially important in the context of user modeling. We provide multiple query modalities by which the user can pose unconstrained, constrained, or instance-based queries. Our interactive agent learns a user model by gaining feedback aboutits recommended movies from the user. We also provide pro-active information gathering to make user interaction more rewarding. In the paper, we outline the current status of our implementation with particular emphasis on the mechanisms used to provide robust and effective recommendations.

Experiences in learning XP practices: a qualitative study

Abstract: Extreme programming (XP) is one of the new agile methodologies for software engineering that has earned a lot of interest the last few years. Through a field study where a group of researchers and students aimed to learn XP through practice, we gathered qualitative data about the different practices of XP and programmers' impression of them in order to do get knowledge on how the different practices work. Findings regarding the most well-known practices are presented in this paper and to a great extent seem to verify claims from the literature. However, some difficulties in the practices are reported.

Preference programming: Advanced problem solving for configuration

Abstract: Configuration problems often involve large product catalogs, and the given user requests can be met by many different kinds of parts from this catalog. Hence, configuration problems are often weakly constrained and have many solutions. However, many of those solutions may be discarded by the user as long as more interesting solutions are possible. The user often prefers certain choices to others (e.g., a red color for a car to a blue color) or prefers solutions that minimize or maximize certain criteria such as price and quality. In order to provide satisfactory solutions, a configurator needs to address user preferences and user wishes. Another important problem is to provide high-level features to control different reasoning tasks such as solution search, explanation, consistency checking, and reconfiguration. We address those problems by introducing a preference programming system that provides a new paradigm for expressing user preferences and user wishes and provides search strategies in a declarative and unified way, such that they can be embedded in a constraint and rule language. The preference programming approach is completely open and dynamic. In fact, preferences can be assembled from different sources such as business rules, databases, annotations of the object model, or user input. An advanced topic is to elicit preferences from user interactions, especially from explanations of why a user rejects proposed choices. Our preference programming system has successfully been used in different configuration domains such as loan configuration, service configuration, and other problems.

Being jane malkovich: a look into the world of an XP customer

Abstract: One of the pivotal roles in XP is the customer, but little guidance is provided in the literature on the practicalities of succeeding in this role. We used an interpretative in-depth case study to explore a successful XP project. We obtained multiple perspectives on the implementation of the customer role, and this paper includes excerpts from interviews with the customer and other development team members. We found that the interviewees provided a consistent picture of the XP customer role and they agreed that the XP customer role, especially for larger organisations, is very demanding. It requires preparation, skills, attention to detail, and the ability to make critical decisions.

Digging into the fundamentals of extreme programming building the theoretical base for agile methods

Abstract: Extreme programming (XP) is an accepted and widely used agile software development method with active user communities worldwide. There exists a great deal of anecdotal evidence to support the use of XP in different situations. While some empirical evidence regarding the use of a certain composite of XP practices exist, no scientifically grounded theory exists. Based on the notion that software engineering is knowledge-intensive work, we show that generic knowledge management theories can be used to explain how XP practices improve an organization's agility. Tuomi's [I. Tuomi, (!999)] model for knowledge creation is used to explain the different practices of XP. This gives a new perspective to agile processes and enables others to express agile practices in a more generic way. It is shown that agility is a result of a more effective knowledge creation process involving both the customer and development team. Based on this, practical implications and future research needs are identified.

XPSwiki: an agile tool supporting the planning game

Abstract: We present XPSwiki, a tool supporting the XP practices for requirement gathering and project management - user stories and the Planning Game. XPSwiki has been developed in Smalltalk using Squeak Swiki technology. It is accessed through the Internet in a user friendly agile way. XPSwiki keeps track of multiple projects, each with its releases, iterations, user stories, acceptance tests, and engineering tasks. It also manages teams of developers, who sign stories and tasks, and who pair-program them with another team member. XPSwiki allows project tracking and documentation, and is at present in use among real software firms.

A ontology-based process modelling for XP

Abstract: We describe the Extreme Programming Ontology (XPO), a formal model specifying the main concepts used in the extreme programming methodology and their properties. XPO's modular structure was developed using the usual normative top down approach to software engineering process modeling. It relies on a set of core components rooted in three main concepts: organisational role, product and phase. Besides being useful for indexing relevant documents and XP artifacts such as user stories and Wiki pages, XPO is aimed at being a sound basis for nonintrusive analysis of agile processes, mining process data about programmers activity and repositories content in order to extract new concepts potentially identifying critical factors in agile software development. Extension to XPO are also discussed, including other agile methodologies and more general software engineering concepts.

Adaptations for Teaching Software Development with Extreme Programming: An Experience Report

Abstract: Extreme Programming (XP) and other Agile Methods are gaining increasing attention for their ability to successfully deliver quality software on time and on budget. These methods embrace the human aspects of software development placing special value on communication and work environment. This paper explores the experience of teaching a three credit hour Software Design and Development course using a development methodology based upon Extreme Programming. Overall, Extreme Programming appears to be a good fit to the academic setting with some adjustments. Adaptations are suggested for both Extreme Programming and the typical class structure to improve the match.

Extreme Programming and Agile Processes in Software Engineering: 4th International Conference, XP 2003, Genova, Italy, May 25-29, 2003, Proceedings

Abstract: Managing Agile Processes.- XP after Enron - Can It Survive?.- Trailing-Edge Management.- Value Based Management and Agile Methods.- Lean Management - A Metaphor for Extreme Programming?.- Methodology Issues.- Metaphor Design Spaces.- An Experiment Working with RUP and XP.- Bridging Cognitive and Social Chasms in Software Development Using Extreme Programming.- A System Dynamics Simulation Model to Find the Effects of XP on Cost of Change Curve.- Extending Agile Methodologies and XP.- Real-Time Extreme Programming.- Software Development under Stringent Hardware Constraints: Do Agile Methods Have a Chance?.- Maturing XP through the CMM.- Formal Extreme (and Extremely Formal) Programming.- Methods and Tools.- Agile Development Using Naked Objects.- XPSwiki: An Agile Tool Supporting the Planning Game.- CruiseControl.NET: Continuous Integration for .NET.- Tool Support for Complex Refactoring to Design Patterns.- Teaching and Introducing Agile Methodologies.- Experiences in Learning XP Practices: A Qualitative Study.- Swimming around the Waterfall: Introducing and Using Agile Development in a Data Centric, Traditional Software Engineering Company.- Cross-Continent Development Using Scrum and XP.- Coaching Coaches.- Testing.- Where Do Unit Tests Come from?.- Three Patterns in Java Unit Testing.- XP with Acceptance-Test Driven Development: A Rewrite Project for a Resource Optimization System.- A Customer Test Generator for Web-Based Systems.- A Framework for Testing at the Edge - An Experience Report.- Pair Programming.- An Empirical Analysis on the Discontinuous Use of Pair Programming.- Pair-Programming Effect on Developers Productivity.- When Does a Pair Outperform Two Individuals?.- Other XP Practices.- Being Jane Malkovich: A Look Into the World of an XP Customer.- Using Actual Time: Learning How to Estimate.- Coaching a Customer Team.- Extreme Design by Contract.- Inline Method Considered Helpful: An Approach to Interface Evolution.- Experience Reports.- Practical Experiences of Agility in the Telecom Industry.- XP-Call in the Social Workers.- Embracing Change: An XP Experience Report.- Extreme Makeover: Bending the Rules to Reduce Risk Rewriting Complex Systems.- Research Reports: Methods and Tools.- Component-Oriented Agile Software Development.- Unit Testing beyond a Bar in Green and Red.- Developing Testable Web-Applications with Bugkilla.- Extreme Programming: A More Musical Approach to Software Development?.- Automated Extract Component Refactoring.- Successful Automation of GUI Driven Acceptance Testing.- Extreme Terseness: Some Languages Are More Agile than Others.- EnterpriseXP: Can the Combination of XP and DSDM Improve the Appeal of XP to the Business Community?.- Using Function Points in XP - Considerations.- Refactoring with Aspects.- Research Reports: Experience Reports.- Extreme Programming at Work.- Combining Agile Practices with UML and EJB: A Case Study in Agile Development.- Practice Makes Perfect.- A Designing Practice and Two Coding Practices for Extreme Programming (XP).- Practical Aspects of XP Practices.- Scaling Extreme Programming in a Market Driven Development Context.- Building Standard ERP Software Packages Using Self-developed Agile Methodologies.- Convincing the Inconvincable.- Comparing Extreme Programming to Traditional Development for Student Projects: A Case Study.- XP: Good for Anything Other than Software Development?.- Extreme Educational Symposium.- Using Instructor Written Acceptance Tests Using the Fit Framework.- Teaching Team Work: An Extreme Week for First-Year Programmers.- Design-led & Design-less: One Experiment and Two Approaches.- Agile Teaching of an Agile Software Process.- Five Challenges in Teaching XP.- Challenges in Teaching Test Driven Development.- Filleting XP for Educational Purposes.- Using XP with Children for Learning Mathematics.- Using Metaphors in eXtreme Programming Projects.- Ph.D. Symposium.- Doctoral Symposium at XP 2003.- Collaboration on Software Tasks.- Unit Testing Using Design by Contract and Equivalence Partitions.- Exploring the XP Customer Role.- Extending Testability for Automated Refactoring.- Software Configuration Management for Test-Driven Development.- A Study on Introducing XP to a Software Development Company.- Teaching eXtreme Programming in a Project-Based Capstone Course.- Mitigating Risks in Mobile System Development.- Extreme Advertised Bidding.- Software Effort Estimation: Planning XP Guidelines Compared to Research on Traditional Software Development.- Collecting Data in Web Service Development.- Measuring the Effectiveness of Agile Methodologies Using Data Mining, Knowledge Discovery and Information Visualization.- Evaluation of New Software Engineering Methodologies.- Evaluation of Product Metrics Applied to Agile Methodologies.- Panels.- Coaching for Agile and Xtreme Practices A Fishbowl with Piranhas.- XP Practices versus Values?.- Test Driven Development (TDD).

Teaching team work: an extreme week for first-year programmers

Abstract: Professional software development implies team work Therefore working in a team should be an essential part in the software engineering curriculum We use Extreme Programming (XP) as a high-discipline software development methodology to teach software engineering within a team quite early in the curriculum This seems not easy at first sight, as XP is aimed mainly at experienced programmers But XP is highly motivating for students if it can be applied within the framework of a real project After their first year of programming, students at the University of Hamburg get the chance to take part in a three week project that includes one week of intensive programming This programming week in the middle is organized following XP principles In this paper we describe the way we adopt XP for this week, argue about the circumstances for a compact XP-like software engineering week, and reflect on the experience we made

Agile development using naked objects

Abstract: Naked objects are core business objects that are exposed directly to the user, by means of a suitable framework. As well as offering benefits to the finished system, the use of naked objects also facilitates the use of agile development techniques. In particular, it enables the concept of an exploration phase during which users and developers prototype the user interface and the underlying business object model simultaneously. During the subsequent delivery phase, naked objects make it easier to adopt the extreme programming discipline of writing executable user acceptance tests in advance of writing the code to implement a particular story.

Developing a Tool Supporting XP Process

Abstract: We present the development of XPSwiki, a tool supporting the XP practices for requirement gathering and project management – user stories and the Planning Game. XPSwiki has been developed in Smalltalk using Squeak Swiki technology, and is accessed through the Internet in a user friendly, agile way. It keeps track of multiple projects, each with its releases, iterations, user stories, acceptance tests, and tasks. XPSwiki allows project tracking, and automates documentation generation and metrics collection. It is presently in use in real software development environments.

The extreme programming bandwagon: revolution or just revolting?

Abstract: The software development field is constantly advancing; all programmers know that and most of us embrace it. Indeed, proponents of extreme programming (XP) must embrace change vehemently. While the paper's title suggests cynicism, thus leading to possible confusion over its thesis, the author likes the software industry's evolution and maturation. Still, he is concerned about some aspects of the new agile methodologies. He concludes that there are a multitude of development scenarios where agile approaches can excel, but at least an equal number where it is destined to fail. For example, XP's proponents openly admit that XP does not tend itself to mission- or safety-critical applications, and large teams will find the oral communication mechanism difficult to implement. The key here is to know your options and understand when you should use one over another.

Maturing XP through the CMM

Abstract: Extreme Programming (XP) and the Capability Maturity Model (CMM) are two recently emerging models addressing the difficulty of developing and delivering high-quality software products. The CMM gives guidelines for what to do at an organizational level, while XP says how to develop software at a project level. Together these models form a comprehensive framework for structuring the software development organization. Drawing from previous software engineering knowledge as well as personal experiences of coaching XP teams this paper gives practical suggestions for how to combine the two models. The paper shows that it is not only possible, but also advantageous to use XP as a springboard for reaching the highest CMM maturity level and assuring the long-term goals of the software development organization.

Supporting requirements engineering in extreme programming: managing user stories

Abstract: One objective for the agile methods is to lower cost of changing requirements. Currently the most popular agile software development method is Extreme Programming (XP). XP addresses this issue by simplifying management tasks and documentation while the traditional software engineering places more emphasis on strict control and extensive documentation. Requirements management (RM) is the activity that ensures that requirements are traceable and all changes to requirements are properly handled. In a dynamic and fast moving project with an iterative process, RM may tie up too much resources. Requirements management and configuration management (CM) are only implicitly addressed by XP. It may be that the method developers viewed RM and CM too bureaucratic, heavy weight or ceremonial to be included in XP. Currently, in the XP process, user requirements called as “user stories” are written and managed on paper cards. The objective of this paper is to examine the challenges involved in the requirements management in an XP project. The aim is also to study possibilities to integrate the support for user story management into single tool framework. Based on the study, an approach for managing user stories with the respect of XP’s basic principles is depicted. Our study is based on an empirical XP case study. According to our study, the following issues were recognized especially important when considering the management of requirements in XP. First, XP provides the basic set of practices that should be shaped into the development situation. This means that practices are tailored for the purposes of a project and the organization, and they can be further changed on-the-fly on periodic process assessments, i.e. if they do not work. Thus, the tool support should not force detailed procedures but provide just enough basic abilities for storing, relating and retrieving user stories and tasks. Second, the tool should allow the XP process to remain agile. This means that the tool should not jeopardize XP’s intentions for open communication and lightweight management and documentation. Third, requirements management tool support should be integrated into the project’s overall development environment. This allows the project team to operate via one channel from a user story definition, through implementation, up to testing. Our solution for the management of user stories and tasks is called StoryManager. The solution has been integrated as plug-in into Eclipse –tool integration framework to enable integrated environment for an XP project.

Extreme programming at work

Abstract: This article describes our experience concerning the introduction and use of extreme programming within a research project and a commercial project with customers. After a short introduction on the two projects, the article points out how the different practices of XP have been used in both projects and which differences we have found in their implementation.

Requirement tracking: a streamlined approach

Abstract: The streamlined approach is a midrange approach to requirement tracking that rejects both a high degree of formality (such as requirements matrices) and informal techniques (such as "user stories"). The basic requirement unit is the requirement statement, not the document, or the use case. Typically, requirements statements are from one to four sentences long. The key concept of the streamlined approach is that of the concrete software requirement. The two primary characteristics are: 1) The requirement is linked to a single software deliverable which it specifies. 2) There exists a well defined completion criterion for determining when the deliverable satisfies the requirement.

Using actual time: learning how to estimate

Abstract: This paper discusses and examines the experience we have gained in using agile planning and tracking tools, with particular reference to a recent very successful project called M@rketInfo. The aim herein is to demonstrate the efficacy of alternative methods based on actual time as compared to the more consolidated methods of Yesterday's Weather, Velocity and Ideal Time. We shall also introduce some significant metrics to help the reader acquire a deeper understanding of the project and the techniques used.

What's so eXtreme about doing things right?

Abstract: Agile Methods are advocated as a way of producing better software. Advocates of agile methods suggest that practices such as keeping in close communication with your customers, frequent integration, and frequent assessment of project status will enable us to produce software that has value for the customer - quality software. It's hard to argue with that. But why is this any different than simply "good" software development practice? Why does saying "Scrum" "Agile" or "XP" grab peoples' attention? Why does it take a name for useful practices to be accepted.This panel will help us understand the role of hype in getting useful practices accepted or rejected. We will explore why it is that these good ideas have not been more widely used. Some of the questions that the panel and the audience will explore are: Why do we ignore proven practices until we see them packaged as a "method?" Can we do something different in the workplace or in school to teach these practices? Or is it the case that these practices are not universally good?This panel talks about agility in a different context than what is typical: we won't just discuss what agile practices are. We will explore why they are not more widely adopted, especially when not packaged as part of a "named" method like XP. And we will discuss why projects suffer even when the methods that can help them are well known. This panel will provide an entertaining and thought provoking forum for discussing an issue that is ever present in the world of technology: the role of hype. We concentrate on agile practices, moving beyond simply enumerating them, to discussing why they are not more widely adopted.

Practical Software Engineering: Analysis and Design for the .Net Platform

Abstract: List of Figures. Preface. 1. Introduction. What Is Software Engineering. The Case Study. The Process. I. SYSTEM SPECIFICATION. 2. Business Model. Introduction. Approach. Case Study. Summary. 3. System Requirements. Introduction. Approach. Case Study. Summary. 4. User Experience Model. Introduction. Approach. Case Study. Summary. II. SYSTEM ANALYSIS AND DESIGN. 5. Analysis Model. Introduction. Approach. Case Study. Summary. 6. Design Model. Introduction. Approach. Case Study. Summary. 7. Implementation Model. Introduction. Approach. Case Study. Summary. 8. Role-Based Security. Introduction. Approach. Case Study. Summary. 9. Testing. Introduction. Approach. Case Study. Summary. 10. Traceability at Work. Introduction. The Scenario. Impact Analysis. Summary. Appendix A: Future Vision. Appendix B: BooksREasy Vision. Appendix C: BooksREasy User Stories. Appendix D: User Account Management Use Cases. Bibliography. Index. 0321136195T10012003

Perspectives on end user development

Abstract: The goal of the workshop is to bring about a coherent research agenda in the field of end user development. We seek contributors concerned with: adaptability, adaptivity, tailoring of system functionality and user interfaces, the use of annotations for individuals and user groups, and use of effective visual and multimedia representations.

Case-Based User Modeling in an Experience Management System.

Abstract: Experience-based continuous learning is essential for improving products, processes, and technologies in emerging as well as in established areas of business and engineering science. It can be facilitated by case-based organizational learning, meaning that relevant experience is captured in the form of cases for reuse in a corporate experience repository (case base; experience base; EB). For obvious reasons, learning from experience needs to be a permanent endeavor. Thus, an organization has to handle a “continuous stream of experience”. For this purpose, a learning organization, called “Experience Factory” (EF; Basili et al. 1994, Althoff et al. 2000), was established at Fraunhofer IESE with the Corporate Information Network (CoIN) initiative (Althoff et al. 2001). On one side, CoIN grants access to intranet-based information like organizational processes and news and, on the other side, case-based access to project management experiences. The objective of the next development step of CoIN is to provide users with valuable information/knowledge at the right time, in an adequate representation, and within the actual context (“just-intime”). In this article, we describe ongoing and planned work to enhance our existing experience management system. We introduce new strategies to capture, process, disseminate, and exchange knowledge. Case-based reasoning (CBR) is used for both knowledge modeling/retrieval/adaptation as well as for a “learning from example” based approach to user modeling. A brief outlook concludes this article.

Designing for flexibility: separating user interface design from program logic and data

Abstract: In modern software development it is increasingly important to bear in mind that the software should match with changing user requirements. The "design for change" perspective may not have been completely understood in the design for World Wide Web based applications. In this paper, we present methods to modularize storage access, domain objects, program logic and user interface into manageable modules. In our opinion, this will lead to better understanding of the software, help the users and programmers to communicate and help the programmers to manage their tasks. We shall, too, propose methods to express some of these modules in a declarative (XML) language, instead of a programming language.As a case study, we consider MDV, a document management program and demonstrate the practical benefits gained by using the modularization.

Using XP with children for learning mathematics

Abstract: This paper presents an interdisciplinary case study of using extreme programming (XP) in a mathematics education research project. The educational focus of the study was the use of images and metaphors by children. The practices of XP allowed researchers to access students' mathematical images and metaphors in a naturalistic setting centered on a real task, rather than in a purely education research-laboratory context.