Yaser Ghanam

Making the leap to a software platform strategy: Issues and challenges

Context: While there are many success stories of achieving high reuse and improved quality using software platforms, there is a need to investigate the issues and challenges organizations face when transitioning to a software platform strategy. Objective: This case study provides a comprehensive taxonomy of the challenges faced when a medium-scale organization decided to adopt software platforms. The study also reveals how new trends in software engineering (i.e. agile methods, distributed development, and flat management structures) interplayed with the chosen platform strategy. Method: We used an ethnographic approach to collect data by spending time at a medium-scale company in Scandinavia. We conducted 16in-depth interviews with representatives of eight different teams, three of which were working on three separate platforms. The collected data was analyzed using Grounded Theory. Results: The findings identify four classes of challenges, namely: business challenges, organizational challenges, technical challenges, and people challenges. The article explains how these findings can be used to help researchers and practitioners identify practical solutions and required tool support. Conclusion: The organizations decision to adopt a software platform strategy introduced a number of challenges. These challenges need to be understood and addressed in order to reap the benefits of reuse. Researchers need to further investigate issues such as supportive organizational structures for platform development, the role of agile methods in software platforms, tool support for testing and continuous integration in the platform context, and reuse recommendation systems.

Extreme Product Line Engineering: Managing Variability and Traceability via Executable Specifications

Extreme Programming (XP) has been reported to work well by valuing principles of simplicity, lightweight practices, effective feedback and continuous process and product improvement. This paper describes an approach towards managing software product lines in a setting where XP practices are common. The paper is an action research describing a case where we handled variability in the domain of intelligent home systems to satisfy a range of requirements by our industrial partner. The paper delves into how variability and traceability of requirements can be managed via executable specifications. A case study was used to evaluate the approach, and it provided initial insights on its feasibility and usefulness.

Linking feature models to code artifacts using executable acceptance tests

A feature model is a representation of the requirements in a given system abstracted at the feature level. Linking conceptual requirements in feature models to actual implementation artifacts provides for many advantages such as increased program comprehension, implementation completeness assessment, impact analysis, and reuse opportunities. However, in practice, as systems evolve, traceability links between the model and the code artifacts may become broken or outdated. In this paper, we contribute an approach to provide traceability links in a way that ensures consistency between the feature model and the code artifacts, enables the evolution of variability in the feature model, and supports the product derivation process. We do that by using executable acceptance tests as a direct traceability link between feature models and code artifacts. We evaluate our approach and present a brief overview of the tool support we provide.

Extreme Product Line Engineering – Refactoring for Variability: A Test-Driven Approach

Software product lines - families of similar but not identical software products - need to address the issue of feature variability. That is, a single feature might require various implementations for different customers. Also, features might need optional extensions that are needed by some but not all products. Software product line engineering manages variability by conducting a thorough domain analysis upfront during the planning phases. However, upfront, heavyweight planning approaches are not well-aligned with the values of minimalistic practices like XP where bottom-up, incremental development is common. In this paper, we introduce a bottom-up, test-driven approach to introduce variability to systems by reactively refactoring existing code. We support our approach with an eclipse plug-in to automate the refactoring process. We evaluate our approach by a case study to determine the feasibility and practicality of the approach.

Reactive Variability Management in Agile Software Development

Agile organizations focus on developing software systems that satisfy their current customer base, without worrying about best practices to handle variations of requirements in the system. Scaling agile methods up to adopt variability management practices in their traditional form is challenging. In this paper, we discuss the challenges and we contribute a lightweight, iterative approach that enables agile organizations to manage variability on demand in a reactive manner. The approach relies on agile practices like iterative development, refactoring, and continuous integration and testing. We present a case study to show how the approach was used to handle variability arising from technical and usability issues, and we provide a discussion of the advantages and limitations of the approach.

Utilizing Digital Tabletops in Collocated Agile Planning Meetings

In agile software development, planning meetings play a pivotal role in establishing a concrete under-standing of customerspsila requirements. Using tools to enhance the effectiveness of the planning meetings without affecting the agility of the practices or disturbing the traditional settings is a challenging task. In this paper, we propose the use of digital tabletops as a means of collaboration in agile planning meetings for collocated teams. To support this proposal, we introduce Agile Planner for Digital Tabletops, a planning tool that was specifically designed for use on large horizontal displays. A multipart study involving a variety of qualitative methodologies was conducted to evaluate this approach. The study involved 14 individual participants plus a five member agile team. The individual evaluation suggested that in general, the tool is usable with minor issues to be considered in future design revisions. The agile team evaluation revealed a significant interest in the tool and its added benefits to the agility of the planning meeting with some issues to be further enhanced.

A report on the XP workshop on agile product line engineering

Software Product Line Engineering (SPLE) promises to lower the costs of developing individual applications as they heavily reuse existing artifacts. Besides decreasing costs, software reuse achieves faster development and higher quality. Traditionally, SPLE favors big design upfront and employs traditional, heavy weight processes. On the other hand, agile methods have been proposed to rapidly develop high quality software by focusing on producing working code while reducing upfront analysis and design. Combining both paradigms, although is challenging, can yield significant improvements. In this workshop, we discussed the challenges, the research questions and the tradeoffs that need to be addressed for such an integration to enjoy success.

From Desktop to Tabletop: Migrating the User Interface of AgilePlanner

Digital tabletops are emerging interactive systems that support group collaborations. To utilize digital tabletops for agile planning meetings, we migrated a desktop based planning tool --- AgilePlanner to a digital tabletop. This paper reports on challenges of the migration and illustrates differences between user interactions on a digital tabletop and on a desktop. Moreover, lessons and experiences learnt from our design process are highlighted to facilitate future tabletop application design.

Using Acceptance Tests for Incremental Elicitation of Variability in Requirements: An Observational Study

Variability in software systems refers to the notion that the components constituting the software may vary due to a range of factors including diverse customer needs, technical constraints, and business strategies. Traditionally, variability has been treated proactively by investing in an upfront domain analysis phase. Such proactive treatment of requirements is not encouraged in agile environments. This paper provides an observational study examining a reactive approach to variability wherein acceptance tests are used to elicit variability from requirements in an incremental manner. The findings suggest the following: the approach does support the evolutionary nature of agile development, the approach is easy and quick to learn, using acceptance tests yields consistent variability interpretations, and acceptance tests -- on their own -- may be insufficient to reflect implicit variability constraints.

Adapting existing applications to support new interaction technologies: technical and usability issues

Engineering interactive systems for use on emerging technologies such as touch-enabled devices and horizontal displays is not straightforward. Firstly, the migration process of a system from an old hardware platform to new multi-touch displays is challenging. Issues pertaining to scaling, orientation, new input mechanisms, novel interaction techniques and different SDKs need to be examined. Secondly, even after we manage to understand and resolve these issues, we need to find effective ways to migrate applications and maintain them. This paper contributes a thorough analysis of the technical and usability issues that need to be considered when migrating systems to different touch-enabled technologies including vertical and horizontal displays.