Predicting mental health conditions from speech has been widely explored in recent years. Most studies rely on a single sample from each subject to detect indicators of a particular disorder. These studies ignore two important facts: certain mental disorders tend to co-exist, and their severity tends to vary over time. This work introduces a longitudinal dataset labeled with depression, anxiety, and stress scores using the DASS-21 self-report questionnaire, and describes a machine-learning pipeline to determine the severity of the three mental disorders using acoustic features extracted from speech samples of this dataset. Our initial findings suggest that healthy participants adhere more to the study procedure than participants who exhibit indicators of depression, anxiety, and stress and demonstrate that a one-dimensional convolutional neural network, trained on VGG-19 features, predicts the severity of depression, anxiety, and stress with high accuracy.

We explore ways to use speech data to screen for indications of Alzheimer’s dementia (AD). In particular, we describe our approach to the ICASSP 2023 Signal Processing Grand Challenge, which involves extrapolating from models learned from English speech samples, to Greek speech samples, to determine which subjects have AD. By using acoustic and linguistic features, inspired by clinical research on AD, our top-performing classification model achieves 69% accuracy in distinguishing AD patients from healthy controls, and our regression model attains an RMSE of 4.8 for inferring cognitive testing scores. These outcomes underscore the potential of our explainable model for detecting cognitive decline in AD patients via speech, and its applicability in clinical settings.

Abstract In recent years, we have been witnessing a rapid increase of research on exergames—i.e., computer games that require users to move during gameplay as a form of physical activity and rehabilitation. Properly balancing the need to develop an effective exercise activity with the requirements for a smooth interaction with the software system and an engaging game experience is a challenge. Model-driven software engineering enables the fast prototyping of multiple system variants, which can be very useful for exergame development. In this paper, we propose a framework, PhyDSLK, which eases the development process of personalized and engaging Kinect-based exergames for rehabilitation purposes, providing high-level tools that abstract the technical details of using the Kinect sensor and allows developers to focus on the game design and user experience. The system relies on model-driven software engineering technologies and is made of two main components: (i) an authoring environment relying on a domain-specific language to define the exergame model encapsulating the gameplay that the exergame designer has envisioned and (ii) a code generator that transforms the exergame model into executable code. To validate our approach, we performed a preliminary empirical evaluation addressing development effort and usability of the PhyDSLK framework. The results are promising and provide evidence that people with no experience in game development are able to create exergames with different complexity levels in one hour, after a less-than-two-hour training on PhyDSLK. Also, they consider PhyDSLK usable regardless of the exergame complexity.

Bug assignment (BA), the process of ranking developers according to their potential ability to fix a given bug, is an important software‐engineering task. BA usually requires the development of an expertise profile for each developer, and formulation of a similarity metric to estimate the relevance of developers to the bug. This needs us to answer the following question: ‘what is the information value of various contributions of developers in BA research?’ We address this question by making the following contributions. (i) We enhance the expertise metric of our prior work, vocabulary and time‐based BA, to consider information regarding various sources of expertise with different importance. We show that this can improve the effectiveness of bug‐assignment process. (ii) Using this ‘Multisource’ expertise metric, we investigate the information value of different pieces of information in open‐source repositories for BA. We show that in addition to bug‐fixing contributions, other technical and even social contributions of developers within the version‐control system are useful information for BA. (iii) We provide a curated, up‐to‐date data set including technical information of 13 popular open‐source projects in Github. To the best of our knowledge, this is the most comprehensive data set, currently available for bug‐assignment research.

Abstract Bug assignment is the task of ranking candidate developers in terms of their potential competence to fix a bug report. Numerous methods have been developed to address this task, relying on different methodological assumptions and demonstrating their effectiveness with a variety of empirical studies with numerous data sets and evaluation criteria. Despite the importance of the subject and the attention it has received from researchers, there is still no unanimity on how to validate and comparatively evaluate bug‐assignment methods and, often times, methods reported in the literature are not reproducible. In this paper, we first report on our systematic review of the broad bug‐assignment research field. Next, we focus on a few key empirical studies and review their choices with respect to three important experimental‐design parameters, namely, the evaluation metric(s) they report, their definition of who the real assignee is, and the community of developers they consider as candidate assignees. The substantial variability on these criteria led us to formulate a systematic experiment to explore the impact of these choices. We conducted our experiment on a comprehensive data set of bugs we collected from 13 long‐term open‐source projects, using a simple Tf‐IDf similarity metric. On the basis of our arguments and/or experiments, we provide useful guidelines for performing further bug‐assignment research. We conclude that mean average precision (MAP) is the most informative evaluation metric, the developer community should be defined as “all the project members,” and the real assignee should be defined as “any developer who worked toward fixing a bug.”

Summary Bug‐assignment (BA), the task of ranking developers in terms of the relevance of their expertise to fix a new bug report is time consuming, which is why substantial attention has been paid to developing methods for automating it. In this article, we describe a new BA approach that relies on two key intuitions. Similar to traditional BA methods, our method constructs the expertise profile of project developers, based on the textual elements of the bugs they have fixed in the past; unlike traditional methods, however, our method considers only the programming keywords in these bug descriptions, relying on Stack Overflow as the vocabulary for these keywords. The second key intuition of our method is that recent expertise is more relevant than past expertise, which is why our method weighs the relevance of a developer's expertise based on how recently they have fixed a bug with keywords similar to the bug at hand. We evaluated our BA method using a dataset of 93k bug‐report assignments from 13 popular GitHub projects. In spite of its simplicity, our method predicts the assignee with high accuracy, outperforming state‐of‐the‐art methods.

Access control is an essential feature of industrial software systems security mechanisms. Role-based access control (RBAC), which is likely the most popular access-control technique, specifies “user roles” and associates each role with “permissions” to access distinct system functionalities. These role-permissions assignment rules, as well as the types of system users and system functionalities, evolve over time. In this paper, we describe a methodology for analyzing and understanding the RBAC-configuration evolution, its relation to the overall evolutionary lifecycle of industrial systems, and its impact on security vulnerabilities from which the system may suffer. Our methodology considers two different sources of information regarding the RBAC-configuration evolution: 1) the role-permissions matrices of subsequent system versions; and 2) the corresponding concept lattices, implied by these matrices. By examining the evolution of these two system properties, developers can easily notice which versions involve more and more complex RBAC-configuration changes that may indicate higher security risks. We demonstrate our methodology using a study of four popular real-world systems: 1) MediaWiki; 2) Moodle; 3) Joomla; and 4) WordPress. Our findings show that the proposed metrics have strong, positive linear correlations with the security vulnerabilities' properties.

Virtual-GymVRis a platform for serious exergames in virtual reality. Its purpose is to provide older adults with a fun experience, while, at the same time, encouraging them to complete their personalized exercise sessions. The platform takes as input a description of a prescribed exercise, in terms of a posture-transition grammar, and constructs personalized versions of its games by accordingly configuring the behavior of the interactive objects in these games. The game-configuration process essentially controls the placement and the interaction behavior of the games' objects so that they induce the user to adopt the proper postures, as described by the input exercise specification. At run time, the sequence of game events stimulate the user to move to the prescribed exercise postures and, thus, accomplish their own personalized exercise goals. Given the intended user population of older adults, we have designed three different Virtual-GymVRgames with metaphors appropriate for three different types of exercises. Our initial experimentation with the Virtual-GymVRgames indicates that the approach is promising.

The Service-Oriented Computing (SOC) paradigm has evolved over the years to be a comprehensive, interdisciplinary methodology for modern software development.It has gone beyond just a "software componentization technology" to embody and express the software manifestation of a trend that transforms our society from an industrial, production-centric economy into a digital, service-centric economy.Indeed, SOC has already emerged as the principle methodology for software engineering of large complex web-based systems, including cloud-and grid-based systems (Bouguettaya et al. 2013).Nowadays, the SOC paradigm is, however, facing new challenges imposed by the Internet of Things (IoT) that has received significant attention both in industry and in the academic community.IoT enables us to turn a tangible entity into a node on the Internet.It is estimated that more than 50 billion Internet-connected things will be in use worldwide by 2020.Consequently, theoretical foundations and engineering methodologies and techniques for SOC that have been developed for "traditional" systems and environments are more and more questioned when it comes to their application to the IoT systems (Bouguettaya et al. 2017;Qin et al. 2016).IoT poses several fundamental challenges on service-management tasks.Resource constraints are the first concern for most IoT devices and traditional SOC standards (e.g., SOAP and BPEL) are too heavyweight to be applicable in IoT.In addition, unlike the traditional service settings, in the Internet of Things environment, functionality of system components is typically heterogeneous, multi-layered (e.g., IoT devices, data, services), dynamic, and context-aware, bringing significant complexity for service management in IoT.This special issue focuses on techniques for establishing and maintaining IoT infrastructures, platforms and applications based on the SOC paradigm, addressing questions around the design,

Testing is an integral part of the software development lifecycle, approached with varying degrees of rigor by different process models. Agile process models recommend Test Driven Development (TDD) as a key practice for reducing costs and improving code quality. The objective of this work is to perform a cost-benefit analysis of this practice. Previous work by Fucci et al. [2, 3] engaged in laboratory studies of developers actively engaged in test-driven development practices. Fucci et al. found little difference between test-first behaviour of TDD and test-later behaviour. To that end, we opted to conduct a study about TDD behaviours in the "wild" rather than in the laboratory. Thus we have conducted a comparative analysis of GitHub repositories that adopts TDD to a lesser or greater extent, in order to determine how TDD affects software development productivity and software quality. We classified GitHub repositories archived in 2015 in terms of how rigorously they practiced TDD, thus creating a TDD spectrum. We then matched and compared various subsets of these repositories on this TDD spectrum with control sets of equal size. The control sets were samples from all GitHub repositories that matched certain characteristics, and that contained at least one test file. We compared how the TDD sets differed from the control sets on the following characteristics: number of test files, average commit velocity, number of bug-referencing commits, number of issues recorded, usage of continuous integration, number of pull requests, and distribution of commits per author. We found that Java TDD projects were relatively rare. In addition, there were very few significant differences in any of the metrics we used to compare TDD-like and non-TDD projects; therefore, our results do not reveal any observable benefits from using TDD.

The population of older adults relative to the total population is rising rapidly worldwide, and this contributes to an increased burden on healthcare systems. Older adults with complex needs are often limited in their ability to perform basic daily activities, and they may require task-specific supports. With continuous health-monitoring systems, the ability to recognize people's activities in their homes can enable automated assisted living systems, caregivers and clinicians to provide suitable adaptive care. With the advent of miniaturized sensing technology, which can be wearable, it is now possible to collect and store data on different aspects of human movement under realistic independent living conditions.In our most recent Smart Condo™ study, twenty-six participants spent one two-hour session in the one-bedroom living environment, either alone or in pairs, and performed a scripted protocol of activities of daily living. Twelve of these participants wore the commercial smart eyewear device JINS MEME, which collected electrooculography, accelerometer and gyroscope data throughout their sessions. In this paper, we describe our method for offline classification of the participants' activities. We show that this method yields equal or better results with a variety of activities compared to approaches that involve more restrictive wearable device setups. The results demonstrate the suitability of JINS MEME for recognition of activities of daily living and identify limitations associated with the current model.

The number of Web APIs for accessing information and services is continuously increasing, and yet, no tools exist to automate the process of invoking these APIs and composing their responses, which can be time consuming and error prone. In our previous work, we described LRA (Linked REST APIs) [1], a middleware that enables the automatic composition of REST APIs. Although this automation represents a great opportunity to systematize and improve the quality of the process of using Web APIs, LRA's reliance on SPARQL as the user-interaction model may hinder its adoption. Hence, based upon previous work on Linked Data query systems, in this paper we present a tool that takes advantage of the emergent schema of Web API descriptions, in order to simplify the formulation of LRA-compliant queries.

Virtual-patient simulators play an important role in modern medical education. These simulators provide a safe environment for learning, give contextual feedback to learners, and allow the learner to move beyond the time and space constraints of traditional face-to-face medical instruction. In this paper, we present an interactive simulation system, LiveBook. This system places learners in the role of a clinician who investigates the symptoms of a patient, asking questions (and receiving answers) in natural language. Once the learner has completed a case by selecting the most plausible diagnosis, LiveBook provides detailed feedback on the student's performance. The first LiveBook cases are currently being piloted in the area of Pediatrics and the service is available at https://live-book.org. Based on our initial experience with the pilot, we believe that LiveBook can be a valuable addition to the curriculum of future diagnosticians, enabling them to apply their knowledge and develop their diagnostic problem-solving skills in the context of realistic scenarios.

Recognizing the occupants movement and locations within a home is a basic functionality, underlying a variety of smart-home services, including energy management, ambient environment control, and assistive-living services for seniors and people with disabilities. The outdoor-localization variant of the problem is effectively addressed with the use of GPS; however, GPS does not work well inside buildings, which makes the indoor positioning problem a very active research topic. In this paper, we report on a study of the indoor-localization problem, relying on easy-to-deploy, inexpensive, BLE-enabled stickers and beacons and WiFi access points.

Over the last decade, an exponentially increasing number of REST services have been providing a simple and straightforward syntax for accessing rich data resources. To use these services, however, developers have to understand "information-use contracts" specified in natural language, and, to build applications that benefit from multiple existing services they have to map the underlying resource schemas in their code. This process is difficult and error-prone, especially as the number and overlap of the underlying services increases, and the mappings become opaque, difficult to maintain, and practically impossible to reuse. The more recent advent of the Linked Data formalisms can offer a solution to the challenge. In this paper, we propose a conceptual framework for REST-service integration based on Linked Data models. In this framework, the data exposed by REST services is mapped to Linked Data schemas, based on these descriptions, we have developed a middleware that can automatically compose API calls to respond to data queries (in SPARQL). Furthermore, we have developed a RDF model for characterizing the access-control protocols of these APIs and the quality of the data they expose, so that our middleware can develop "legal" compositions with desired qualities. We report our experience with the implementation of a prototype that demonstrates the usefulness of our framework in the context of a research-data management application.

Bug deduplication, ie, recognizing bug reports that refer to the same problem, is a challenging task in the software‐engineering life cycle. Researchers have proposed several methods primarily relying on information‐retrieval techniques. Our work motivated by the intuition that domain knowledge can provide the relevant context to enhance effectiveness, attempts to improve the use of information retrieval by augmenting with software‐engineering knowledge. In our previous work, we proposed the software‐literature‐context method for using software‐engineering literature as a source of contextual information to detect duplicates. If bug reports relate to similar subjects, they have a better chance of being duplicates. Our method, being largely automated, has a potential to substantially decrease the level of manual effort involved in conventional techniques with a minor trade‐off in accuracy. In this study, we extend our work by demonstrating that domain‐specific features can be applied across projects than project‐specific features demonstrated previously while still maintaining performance. We also introduce a hierarchy‐of‐context to capture the software‐engineering knowledge in the realms of contextual space to produce performance gains. We also highlight the importance of domain‐specific contextual features through cross‐domain contexts: adding context improved accuracy; Kappa scores improved by at least 3.8% to 10.8% per project.

Mobile video streaming becomes increasingly useful in a variety of contexts (social interaction, education, and entertainment) and increasingly feasible with the rapid advancement of wireless networks and mobile technologies. In this paper, we present, Kaleidoscope, a cloud platform for multimedia streaming on mobile devices, enhanced with textual and touch-display interactions for a rich user experience. We evaluate the Kaleidoscope system on two different clouds at different locations, testing the streaming quality, and CPU and memory usage, using different numbers of clients.

In this paper, we describe a method for transforming and migrating data schemas developed for RDBMS to HBase. The method consists of a set of HBase-organization guidelines and a four-step data-schema transformation process that HBase application developers may follow during the migration of their application data from RDBMSs to HBase. The method also considers data-access paths extracted from query logs, in order to improve the quality of the transformation and the eventual access efficiency of the HBase repository. We illustrate and validate the method with a case study.

Change-impact analysis, namely “identifying the potential consequences of a change” is an important and well studied problem in software evolution. Any change may potentially affect an application's behaviour, performance, and energy consumption profile. Our previous work demonstrated that changes to the system-call profile of an application correlated with changes to the application's energy-consumption profile. This paper evaluates and describes GreenAdvisor, a first of its kind tool that systematically records and analyzes an application's system calls to predict whether the energy-consumption profile of an application has changed. The GreenAdvisor tool was distributed to numerous software teams, whose members were surveyed about their experience using GreenAdvisor while developing Android applications to examine the energy-consumption impact of selected commits from the teams' projects. GreenAdvisor was evaluated against commits of these teams' projects. The two studies confirm the usefulness of our tool in assisting developers analyze and understand the energy-consumption profile changes of a new version. Based on our study findings, we constructed an improved prediction model to forecast the direction of the change, when a change in the energy-consumption profile is anticipated. This work can potentially be extremely useful to developers who currently have no similar tools.

Bug triaging and assignment is a time-consuming task in big projects. Most research in this area examines the developers' prior development and bug-fixing activities in order to recognize their areas of expertise and assign to them relevant bug fixes. We propose a novel method that exploits a new source of evidence for the developers' expertise, namely their contributions to Q&A platforms such as Stack Overflow. We evaluated this method in the context of the 20 largest GitHub projects, considering 7144 bug reports. Our results demonstrate that our method exhibits superior accuracy to other state-of-the-art methods, and that future bug-assignment algorithms should consider exploring other sources of expertise, beyond the project's version-control system and bug tracker.

REST has become a very popular architectural style for service-oriented systems, primarily due to its ease of use and flexibility. However, the lightweight nature of its syntax does not necessitate the use of systematic methods and tools. In this work, we argue that such tools can greatly facilitate complex engineering tasks, including service discovery and evolution. We present the WSDarwin set of tools to generate WADL interfaces for REST services, to compare service interfaces to identify differences between versions, and to compare service offerings of different vendors to facilitate service discovery and interoperability.

Service orientation is one of the most popular paradigms for developing modular distributed software systems. In spite of the substantial research effort dedicated to the development of methods and tools to support SOAP-based service-oriented application development, in practice, RESTful services have surpassed SOAP-based services in popularity and adoption, primarily due to the simplicity of their invocation. However, poor adoption of REST specification standards and lack of systematic development tools have given rise to many, more or less compliant, variants of the Restful style constraints, which undermine the evolvability and interoperability of these systems. In this paper, we describe a tool that supports the systematization of RESTful application development, through the use of semi-automatically constructed WADL interface specifications, without compromising the ease of the overall practice. We illustrate the use and advantages of our tool on real-world REST APIs. Additionally, we comment on how REST APIs are documented, especially in comparison to the auto-generated WADLs.

The goal of this Visionary Track on Web Tasking at IEEE World Congress on Services is to provide a forum for researchers and practitioners to present research results and positions on the challenges involved in developing methods, conceptual frameworks, architectures and tools to enable web tasking. The critical question at the core of this activity is how to put resources in the hands of web users, so that they can conduct web tasking with ease. Resources may come from (i) systems of record from enterprises, (ii) systems of instrumentation as in cyber-physical systems and internet of things, and (iii) systems of people including individuals and relationships from across various social networking platforms. Web-tasking research requires interdisciplinary research expertise and collaboration.

In previous work by Alipour et al., a methodology was proposed for detecting duplicate bug reports by comparing the textual content of bug reports to subject-specific contextual material, namely lists of software-engineering terms, such as non-functional requirements and architecture keywords. When a bug report contains a word in these word-list contexts, the bug report is considered to be associated with that context and this information tends to improve bug-deduplication methods. In this paper, we propose a method to partially automate the extraction of contextual word lists from software-engineering literature. Evaluating this software-literature context method on real-world bug reports produces useful results that indicate this semi-automated method has the potential to substantially decrease the manual effort used in contextual bug deduplication while suffering only a minor loss in accuracy.

The Smart-Condo is a hardware/software platform that aims to support and assist an individual in performing a variety of everyday tasks within his/her living space. The key to achieving this goal is being able to recognize the individual's general activities in real-time, without impeding these activities or compromising privacy. Since location and movement constitute meaningful evidence for many everyday tasks (e.g., presence in the bathroom correlates with personal hygiene activities), we are motivated to develop an efficient, accurate, and noninvasive occupant-localization method. To this end, we propose a methodology for planning the deployment of an array of privacy-respecting binary motion sensors. In particular, given the geometric constraints of the deployment space, we generate a model of indoor mobility patterns typical for a single occupant. We then use this model as the basis for a specific optimization problem: maximizing a measure of how well the frequently-visited areas of the living space are covered by a number of sensors, subject to a cardinality constraint on this number. We argue this optimization objective is a good surrogate for maximizing localization accuracy, and prove that it bears exploitable properties that make it receptive to a simple optimization routine. As a result, we obtain sensor configurations with localization accuracy superior to that achievable with the same number of sensors placed manually or randomly in the same environment.

Cloud-based infrastructures enable applications to collect and analyze massive amounts of data. Sometimes these applications are the product of green-field engineering, but frequently they are the product of the evolution of traditional RDBMS-based implementations. In any case, NoSQL databases, endowed with high availability, elasticity and scalability through their easy deployment on cloud-computing platforms, have become an attractive data-storage solution for these big-data applications. Unfortunately, to date, there is little methodological and tool support for migrating existing applications to these new platforms. In this paper, we describe a hybrid architecture for location-aware applications on hierarchical cloud, a methodology for mapping relational (including spatio-temporal) data to HBase, and a process for migrating legacy applications to the new architecture.

Swallowing impairments, or dysphagia, can lead to serious health problems and psychosocial concerns. Effective treatment can be enhanced with the use of adjuvant visual biofeedback from surface electromyography (sEMG) to monitor muscle movement during intensive swallowing exercises. However, access to this therapy is currently possible only in a clinical setting, and is therefore restricted due to limited clinical capacity and technology costs. In this paper, we describe the concept for a new hardware-and-software mobile system for swallowing therapy: Mobili-T. The system, designed by an interdisciplinary team of biomedical engineers, clinicians, and industrial designers, will help patients with dysphagia go through their rehabilitation regimens at home.

Computational-thinking skills are an essential intellectual amplifier for all scientific and professional disciplines. Embedding these skills in the K-12 and University curricula is necessary for training the next generation of thinkers. A widely adopted approach to doing so is through simple and visual programming languages like Scratch and engaging assignments like video-game construction. In this work, we report on an empirical study we conducted with senior undergraduate education students aiming to understand how prior experience enables students to better develop their computation-thinking skills through a Scratch-based video-game assignment.

This paper presents an approach to support the maintenance and evolution of Role-Based Access Control (RBAC) models with reverse-engineered Secure UML models. Starting from the Policy Decision Points (PDP) and Policy Enforcement Points (PEP) of an application, our approach statically reverse-engineers the implemented Secure UML model of an application. The secure UML model is then stored in an RDF triple store for easy querying and exploration. In the context of this study, we extracted the Secure UML model of the GRAND Forum, a web-based forum for the members of the GRAND (Graphics, Animation and New Media) NCE (Networks of Centers of Excellence), that is developed and maintained at the University of Alberta. Using three real use-case scenarios, we illustrate how simple queries to the extracted Secure UML can save developers significant amounts of manual work and support them in their access control related maintenance and evolution tasks.

Code-generation environments have emerged as a new mechanism for building software systems in a systematic manner. At their core, model-driven engineering technologies such as model-to-model and model-to-text transformations are effectively used to build generation engines. However, due to the complexity of model-to-model and model-to-text transformation scripts, which is exacerbated as they are composed in complex transformation chains, developers face technical and cognitive challenges when architecting, implementing, and maintaining code-generation environments. In this paper we present Chain Tracker, a visualization and trace analysis tool for model-to-model and model-to-text transformation compositions. Chain Tracker aims to support developers of code-generation environments by making the usage of model-driven engineering technologies more efficient, less error prone, and less cognitively challenging.

As primarily modular and distributed architectures, service-oriented architectures may impose new challenges in software evolution. Since web services evolve independently, this may cause disruptions to the proper function of consuming software. In this paper, we present \wsd, an Eclipse plug-in to support the evolution of service clients, including (a) identifying the differences between two service versions, (b) automatically adapting the client application to the new version, and (c) testing the client to confirm it functions properly.

Github is a very popular collaborative software-development platform that provides typical source-code management and issue tracking features augmented by strong social-networking features such as following developers and watching projects. These features help ``spread the word'' about individuals and projects, building the reputation of the former and increasing the popularity of the latter. In this paper, we investigate the relation between project popularity and regular, consistent documentation updates. We found strong indicators that consistently popular projects exhibited consistent documentation effort and that this effort tended to attract more documentation collaborators. We also found that frameworks required more documentation effort than libraries to achieve similar adoption success, especially in the initial phase.

The objective of the Personalized Web Tasking (PWT) workshop series is to develop a community interested in the overlap between web services (as interoperable and easily composable components) and configurable personalizable applications. On the one hand, the core web-service community focuses primarily on enabling/supporting the processes around building distributed systems using services as the basic building blocks. On the other hand, user-centric communities have long been interested in enabling end users to customize their own experience using web resources, context-aware computing, and adaptive software, among others. PWT 2014, held during the IEEE World Congress on Services, focused on the overlap between the two areas, and brought together international researchers examining research relevant to this overlap.

Cloud-based infrastructures enable applications to collect and analyze massive amounts of data. Whether these applications are newly developed or they are being evolved from existing RDBMS-based implementations, NoSQL databases offer an attractive platform with which to address this challenge. However, developers find it difficult to effectively manage data in NoSQL databases, because these platforms do not offer much support for data organization. Since poor data organization may abuse the features of the NoSQL database and result in unsatisfactory performance, developing a systematic method for NoSQL database data-schema design is a timely and important problem. In this paper, we focus on geospatial applications, as a family of big-data systems with distinct data types and usage patterns, in need of scalability. We propose the HGrid data model for HBase, based on a hybrid index structure, combining a quad-tree and a regular grid as primary and secondary indices correspondingly. We have comparatively evaluated the performance of HGrid with uniform and skewed data, against two other data models based on quad-tree and regular-grid indices. Our results demonstrate that HGrid scales well and supports efficient performance for range and k-nearest neighbor queries. Although this model does not outperform all its competitors in terms of query response time, it is more flexible for discontinuous and skewed space, and its index requires less space than the corresponding quad-tree and regular-grid indices, which makes its deployment possible with less resources. Through this study, we also formulate a set of guidelines on how to organize data for geospatial applications in HBase.

The Smart-Condo interdisciplinary team (including computing science, industrial design, health psychology and occupational therapy) conducts research on putting ICT in the service of health care, focusing on empowering individuals to take control of their health management. This past year, the focus of our activities has been the development of a framework for the design and development of mobile apps to encourage behavioral changes. Grounding our framework the Theory of Planned Behavior and the Intention-Behavior Gap Theory, we explicitly designed all the functions in our applications to influence behavior. From a technical perspective, the applications support personalization, easy data recording and interactive reviewing, and subtle interventions (reminders and personalized information) to help behavior change. The user interface, informed by design theory, is conceived to make the applications engaging and easy to navigate. Bringing these three areas of knowledge together in the design of our apps will enable the systematic construction of a family of applications that together will have the potential to affect significant behavior change. In this paper we discuss the framework and the first two applications we have developed with it.

Software development is an inherently team-based activity, and many software-engineering courses are structured around team projects, in order to provide students with an authentic learning experience. The collaborative-development tools through which student developers define, share and manage their tasks generate a detailed record in the process. Albeit not designed for this purpose, this record can provide the instructor with insights into the students' work, the team's progress over time, and the individual team-member's contributions. In this paper, we describe an analysis and visualization toolkit that enables instructors to interactively explore the trace of the team's collaborative work, to better understand the team dynamics, and the tasks of the individual team developers. We also discuss our grounded-theory analysis of one team's work, based on their email exchanges, questionnaires and interviews. Our analyses suggest that the inferences supported by our toolkit are congruent with the developers' feedback, while there are some discrepancies with the reflections of the team as a whole.

In the last decade, developers have been increasingly sharing their questions with each other through Question and Answer (Q&A) websites. As a result, these websites have become valuable knowledge repositories, covering a wealth of topics related to particular programming languages. This knowledge is even more useful as the developer community evaluates both questions and answers through a voting mechanism. As votes accumulate, the developer community recognizes reputed members and further trusts their answers. In this paper, we analyze the community's questions and answers to determine the developers' personality traits, using the Linguistic Inquiry and Word Count (LIWC). We explore the personality traits of Stack Overflow authors by categorizing them into different categories based on their reputation. Through textual analysis of Stack Overflow posts, we found that the top reputed authors are more extroverted compared to medium and low reputed users. Moreover, authors of up-voted posts express significantly less negative emotions than authors of down-voted posts.

Service-oriented systems are fundamentally distributed in nature, relying on external services accessible through their public interfaces. Distributed ownership and lack of implementation transparency imply special challenges in the evolution of such systems. In order to alleviate the challenge faced by the consumers of their services, providers should, in principle, take into account the impact that service changes may have on the client applications, in addition to considering the potential benefits to be gained from the evolution of these services. In this paper, we present a decision tree to support the provider's service-evolution decision-making process. Using game theory, we construct the tree that makes explicit the value-cost trade-offs involved in considering the potential evolution of services.

Modern collaborative software-development tools generate a rich data record, over the lifecycle of the project, which can be analyzed to provide team members and managers with insights into the performance and contributions of individual members and the overall team dynamic. This data can be analyzed from different perspectives, sliced and diced across different dimensions, and visualized in different ways. Frequently the most useful analysis depends on the actual data, which makes the design of single authoritative visualization a challenge. In this paper we describe an analysis and visualization tool that supports the flexible run-time mapping of such a data record to a number of alternative visualizations. We have used our framework to analyze and gain an understanding of how individuals work within their teams and how teams differ in their work on these term projects.

Bug-tracking and issue-tracking systems tend to be populated with bugs, issues, or tickets written by a wide variety of bug reporters, with different levels of training and knowledge about the system being discussed. Many bug reporters lack the skills, vocabulary, knowledge, or time to efficiently search the issue tracker for similar issues. As a result, issue trackers are often full of duplicate issues and bugs, and bug triaging is time consuming and error prone. Many researchers have approached the bug-deduplication problem using off-the-shelf information-retrieval tools, such as BM25F used by Sun et al. In our work, we extend the state of the art by investigating how contextual information, relying on our prior knowledge of software quality, software architecture, and system-development (LDA) topics, can be exploited to improve bug-deduplication. We demonstrate the effectiveness of our contextual bug-deduplication method on the bug repository of the Android ecosystem. Based on this experience, we conclude that researchers should not ignore the context of software engineering when using IR tools for deduplication.

In this position paper, we present our early work towards a software architecture for developing product lines of personalized mobile applications.

The service-oriented architecture style supports desirable qualities, including distributed, loosely coupled systems spanning organizational boundaries. Such systems and their configurations are challenging to understand, reason about, and test. Improved understanding of these systems will support activities such as autonomic runtime configuration, application deployment, and development/testing. Simulation is one way to understand and test service systems. This paper describes a literature survey of simulation frameworks for service-oriented systems, examining simulation software, systems, approaches, and frameworks used to simulate service-oriented systems. We identify a set of dimensions for describing the various approaches, considering their modeling methodology, their functionalities, their underlying infrastructure, and their evaluation. We then introduce the services-aware simulation framework (SASF), a simulation framework for predicting the behavior of service-oriented systems under different configurations and loads, and discuss the unique features that distinguish it from other systems in the literature. We demonstrate its use in simulating two service-oriented systems.

Medication adherence is an important challenge for many patients with chronic conditions, most of them elderly. Technology has an important role to play in this area potentially, with electronic devices equipped with reminder capability and medication intake recording. In this paper, we present a remotely programmable pillbox. This pillbox is equipped with a web application which gives the health professional or caregiver a tool to check and program the pill-box. Also, a mobile application is implemented to establish a connection with the web-application to show pills' daily schedule and pill taking notifications.

In this paper we mine the Android bug tracker repository and study the characteristics of the architectural layers of the Android system. We have identified the locality of the Android bugs in the architectural layers of the its infrastructure, and analysed the bug lifetime patterns in each one of them. Additionally, we mined the bug tracker reporters and classified them according to its social centrality in the Android bug tracker community. We report three interesting findings, firstly while some architectural layers have a diverse interaction of people, attracting not only non-central reporters but highly important ones, other layers are mostly captivating for peripheral actors. Second, we exposed that even the bug lifetime is similar across the architectural layers, some of them have higher bug density and differential percentages of unsolved bugs. Finally, comparing the popularity distribution between layers, we have identified one particular layer that is more important to developers and users alike.

Evolutionary changes in object-oriented systems can result in large, complex classes, known as "God Classes". In this paper, we present a tool, developed as part of the JDeodorant Eclipse plugin, that can recognize opportunities for extracting cohesive classes from "God Classes" and automatically apply the refactoring chosen by the developer.

This paper briefly describes the 3rd International Workshop on Software Engineering in Healthcare, held at the 2011 International Conference on Software Engineering.

Maintainability is a desired property of software, and a variety of metrics have been proposed for measuring it, focusing on different notions of complexity and code readability. Many practices have been proposed to improve maintainability through code refactorings: improving the cohesion, simplification of interfaces, renamings to improve understandability. Code conventions are a body of advice on lexical and syntactic aspects of code, aiming to standardize low-level code design under the assumption that such a systematic approach will make code easier to read, understand, and maintain. We present the first stage in our examination of code-convention adherence practices as a proxy measurement for maintainability. Based on a preliminary survey of software engineers, we identify a set of coding conventions that most relate to maintainability. Then we devise a “convention adherence” metric, based on the number and severity of violations of a defined coding convention. Finally, we analyze several open-source projects according to this metric to better understand how consistent different teams are with respect to adopting and conforming to code conventions.

Software evolution analysis plays an important role in several software engineering activities which are mainly related to maintenance tasks. For this purpose, several approaches and tools have been developed to identify and analyze code changes throughout the history of a software system. However, most existing tools are restricted to a specific type of software artifact, are language-dependent and can only be locally executed on a client machine. To overcome these limitations we propose WebDiff, a web-based generic differencing service for various types of software artifacts including source code and UML diagrams.

The service-oriented architecture paradigm prescribes the development of systems through the composition of services, i.e., network-accessible components, specified by (and invoked through) their WSDL interface descriptions. Systems thus developed need to be aware of changes in, and evolve with, their constituent services. Therefore, accurate recognition of changes in the WSDL specification of a service is an essential functionality in the context of the software lifecycle of service-oriented systems. In this work, we present the results of an empirical study on WSDL evolution analysis. In the first part, we empirically study whether VTracker, our algorithm for XML differencing, can precisely recognize changes in WSDL documents by applying it to the task of comparing 18 versions of the Amazon EC2 web service. Second, we analyze the changes that occurred between the subsequent versions of various web-services and discuss their potential effects on the maintainability of service systems relying on them.

Configuration management is a complex task, even for experienced system administrators, which makes self-managing systems a desirable solution. Self-management implies the need for a model based on which configuration changes may be decided. In previous work, we described a method for constructing a state-transition model of application behavior, by observing the application in simulation. This method relied on an expert to manage the (simulated) application in order to collect the necessary observations for constructing the model. However, that method was agnostic about (a) the size of the system space space as implied by the granularity of the observations, and (b) the sufficiency of the actual observations collected for understanding the application in a variety of configurations and environments. In this paper, we replace the (expensive) expert domain knowledge with automatic approaches to ensuring coverage of the application, and demonstrate the superiority of this approach. We present empirical data regarding state space and granularity to explore the use of state models for understanding applications.

We demonstrate the ReaSoN portal, consisting of interactive web-based tools for visualizing, exploring, querying, and integrating academic social networks. We describe how these networks are automatically extracted from bibliographic and citation databases, discuss notions of visibility in such networks which enable a rich set of social network analysis, and demonstrate our novel tools for the visualization and exploration of social networks.

Several types of 3D software visualizations have been developed to communicate information about the products of a software project and, sometimes, the development process itself. These visualizations have been limited in the degree of interactivity they enabled (primarily panning and zooming) and in their accessibility (since in most cases they assumed a particular client platform). In this paper we discuss our 3D visualization of the data collected and extracted in our collaborative software-development platform WikiDev2.0, developed in the Open Wonderland virtual world. The visualization adopts a city metaphor, similar to earlier work, but advances the state of the art by providing a web-accessible distributed 3D environment where multiple users can explore the same project. In this paper we discuss this visualization, which we call WikiDev3D, and we report on our preliminary findings about its effectiveness against the more traditional visualization of the original WikiDev2.0 tool.

Software teams, as they communicate throughout the life-cycle of their projects, generate a substantial stream of textual data. Through emails and chats, developers discuss the requirements of their software system, they negotiate the distribution of tasks among them, and they make decisions about the system design, and the internal structure and functionalities of its code modules. The software research community has long recognized the importance and potential usefulness of such textual information. In this paper, we discuss our recent work on systematically analyzing several textual streams collected through our WikiDev2.0 tool. We use two different text-analysis methods to examine five different sources of textual data. We report on our experience using our method on analyzing the communications of a nine-member team over four months.

Text analysis is an important computational task, as unstructured data including text abound and can potentially provide interesting information and knowledge in a variety of areas. In our collaboration with Digital Humanists, we have started to examine the opportunities that the cloud offers to improving the response times of text-analysis tools so that users can comparatively analyze large text corpora across a variety of dimensions. To that end, we have started migrating existing text analysis tools to the cloud, beginning with TAPoR, the Text Analysis Portal for Research. In this paper, we discuss our experience redesigning and re-implementing four basic TAPoR operations on Hadoop and we report on the performance improvements enabled by the migration.

Abstract Wikis are designed to support collaborative editing, without focusing on individual contribution, such that it is not straightforward to determine who contributed to a specific page. However, as wikis are increasingly adopted in settings such as business, government, and education, where editors are largely driven by career goals, there is a perceived need to modify wikis so that each editor's contributions are clearly presented. In this paper we introduce an approach for assessing the contributions of wiki editors along several authorship categories, as well as a variety of information glyphs for visualizing this information. We report on three types of analysis: (a) assessing the accuracy of the algorithms, (b) estimating the understandability of the visualizations, and (c) exploring wiki editors' perceptions regarding the extent to which such an approach is likely to change their behavior. Our findings demonstrate that our proposed automated techniques can estimate fairly accurately the quantity of editors' contributions across various authorship categories, and that the visualizations we introduced can clearly convey this information to users. Moreover, our user study suggests that such tools are likely to change wiki editors' behavior. We discuss both the potential benefits and risks associated with solutions for estimating and visualizing wiki contributions.

Social network analysis aims at uncovering and understanding the structures and patterns resulting from social interactions among individuals and organizations engaged in a common activity. Since the early days of the field, networks are modeled as graphs modeling social actors and the relations between them. The field has become very active with the maturity of computational machinery to handle large-scale graphs, and, more recently, the automated gathering of social data. We introduce ReaSoN: a comprehensive set of tools for visualizing and exploring social networks resulting from academic research. In doing so, ReaSoN contributes to the understanding as well as fostering of the social networks underlying academic research. We describe the infrastructure, visualizations and analysis provided in our system, as well as the process of extracting the social networks which are latent in bibliographic and citation databases.

Service-oriented architecture is emerging as a compelling paradigm for developing web-based software applications. According to this architectural style, the functional components of the system are implemented in various programming languages as netw

Aspect oriented programming (AOP) supports the encapsulation of concerns cutting across the logical design of object-oriented software, by introducing aspects as a new unit of code. Code fragments, defined within aspects, such as advice or inter-type declarations, can be composed together with traditional system units, such as classes in OO code, using quantification expressions that specify where such fragments are to be injected and executed. The introduction of aspect-orientation in object-oriented software development raises two interesting comprehension questions. First, is the comprehension of AO software more difficult than traditional object-oriented software? Second, can aspects support comprehension tasks of object-oriented developers?

Applications built on reusable component frameworks are subject to two independent, and potentially conflicting, evolution processes. The application evolves in response to the specific requirements and desired qualities of the application's stakeholders. On the other hand, the evolution of the component framework is driven by the need to improve the framework functionality and quality while maintaining its generality. Thus, changes to the component framework frequently change its API on which its client applications rely and, as a result, these applications break. To date, there has been some work aimed at supporting the migration of client applications to newer versions of their underlying frameworks, but it usually requires that the framework developers do additional work for that purpose or that the application developers use the same tools as the framework developers. In this paper, we discuss our approach to tackle the API-evolution problem in the context of reuse-based software development, which automatically recognizes the API changes of the reused framework and proposes plausible replacements to the "obsolete" API based on working examples of the framework code base. This approach has been implemented in the Diff-CatchUp tool. We report on two case studies that we have conducted to evaluate the effectiveness of our approach with its Diff-CatchUp prototype.

Ribonucleic acid (RNA) molecules contain the genetic information that regulates the functions of organisms. Given two different molecules, a preserved function corresponds to a preserved secondary RNA structure. Hence, RNA secondary-structure comparison is essential in predicting the functions of a newly discovered molecule. In this paper, we discuss our SPRC method for RNA structure comparison. In this work, we developed, a novel tree representation of RNA that reflects both its primary and secondary structure and a tree-alignment algorithm, which, given the tree representations of two RNA molecules, produces a sequence of mutations that could transform one RNA molecule to the other. Our SPRC algorithm extends the Zhang-Shasha tree-edit distance calculation algorithm in two ways: first, in addition to the distance, it reports all editing sequences with the same minimum edit cost, and second, it uses a biologically-inspired affine cost function. Furthermore, the SPRC method proposes set of heuristics designed to filter the produced solution set to recommend the simplest editing sequence, as corresponding to the most biologically correct alignment. Experiments on three 5S rRNA families: archaea, eubacteria, and eukaryota, show that SPRC is very effective in producing biologically meaningful RNA secondary structure alignments

Refactoring is an important activity in the evolutionary development of object-oriented software systems. Yet, several questions about the practice of refactoring remain unanswered, such as what fraction of code modifications are refactorings and what are the most frequent types of refactorings. To gain some insight in this matter, we conducted a detailed case study on the structural evolution of Eclipse, an integrated-development environment (IDE) and a plugin-based framework. Our study indicates that: 1) about 70% of structural changes may be due to refactorings; 2) for about 60% of these changes, the references to the affected entities in a component-based application can be automatically updated by a refactoring-migration tool if the relevant information of refactored components can be gathered through the refactoring engine; and 3) state-of-the-art IDEs, such as Eclipse, support only a subset of commonly applied low-level refactorings and lack support for more complex ones, which are also frequent. Based on our findings, we draw some conclusions on high-level design requirements for a refactoring-based development environment

The blogging phenomenon has caught the on-line world by surprise; the number of blogs doubles regularly and the number of daily blog entries seems to also continuously increase. Even more interestingly, blogs seem to compete with authoritative media outlets as a means for delivering news and opinions. The perceived power of blogs to inform and form, public opinion has given rise to several blog-mining services analyzing the blog entries to infer the reputation of their customers. In this paper, we discuss our work on visualizing and systematically analyzing several blogs in the same domain of interest (movies) in order to assess to what extent the buzz of blogs correlates with public opinion.

Software repositories are rich sources of information about the software development process. Mining the information stored in them has been shown to provide interesting insights into the history of the software development and evolution. Several different types of information have been extracted and analyzed from different points of view. However, these types of information have not been sufficiently cross-examined to understand how they might complement each other. In this paper, we present a systematic analysis of four aspects of the software repository of an open source project - source-code metrics, identifiers, return-on-investment estimates, and design differencing - to collect evidence about refactorings that may have happened during the project development. In the context of this case study, we comparatively examine how informative each piece of information is towards understanding the refactoring history of the project and how costly it is to obtain.

As software systems evolve over a long time, non-trivial and often unintended relationships among system classes arise, which cannot be easily perceived through source-code reading. As a result, the developers' understanding of continuously evolving, large, long-lived systems deteriorates steadily. A most interesting relationship is class co-evolution: because of implicit design dependencies clusters of classes change in "parallel" ways and recognizing such co-evolution is crucial in effectively extending and maintaining the system. In this paper, we propose a data-mining method for recovering "hidden" co-evolutions of system classes. This method relies on our UML-aware structural differencing algorithm, UMLDiff, which, given a sequence of UML class models of an object-oriented software system, produces a sequence of "change records" that describe the design-level changes over its life span. The change records are analyzed from the perspective of each individual system class to extract "class change profiles". Each phase of a class change profile is then discretized and classified into one of two general change types: function extension or refactoring. Finally, the Apriori association-rule mining algorithm is applied to the database of categorical class change profiles, to elicit co-evolution patterns among two or more classes, which may be as yet undocumented and unknown. The recovered knowledge facilitates the overall understanding of system evolution and the planning of future maintenance activities. We report on one real world case study evaluating our approach.

Object-oriented software is usually developed through evolutionary processes. To consistently evolve a system, developers have to understand the rationale behind its current design and the evolution trajectory that has led to it. In this paper, we present a method for analyzing the design evolution of object-oriented software systems, for the purpose of providing relevant advice to developers. This method relies on UMLDiff, a heuristic UML-structure differencing algorithm, which, given a sequence of UML class models corresponding to the logical design of a sequence of system code versions, produces a sequence of "change trees" that describe the design-level structural changes between subsequent system versions. A set of design-evolution patterns are then analyzed to understand the rationale underlying design decisions that may affect the software system. We demonstrate how the recovered knowledge provides the basis for mentoring the developers on future maintenance activities.

Service-oriented architecture is emerging as a compelling paradigm for developing Web-based software applications. In this style, the functional components of the system are implemented in various programming languages as network-accessible "services" declaratively specified (in WSDL) and declaratively composed in workflows (using BPEL4WS). Despite this fundamentally distributed conceptualization of service composition, most current middleware assumes that the specification of the service composition is interpreted at run time by a central middleware node. This implies inflexible composition evolution: all parties must be updated concurrently to avoid interaction failures. This paper introduces an intelligent-agent framework that wraps Web services in a conversation layer and is capable of a simple workflow-adaptation function. The conversation layer implements protocols and consults globally shared, declarative policy specifications to resolve conversation failures. Two case studies illustrate this approach.

This paper presents UMLDiff, an algorithm for automatically detecting structural changes between the designs of subsequent versions of object-oriented software. It takes as input two class models of a Java software system, reverse engineered from two corresponding code versions. It produces as output a change tree, i.e., a tree of structural changes, that reports the differences between the two design versions in terms of (a) additions, removals, moves, renamings of packages, classes, interfaces, fields and methods, (b) changes to their attributes, and (c) changes of the dependencies among these entities. UMLDiff produces an accurate report of the design evolution of the software system, and enables subsequent design-evolution analyses from multiple perspectives in support of various evolution activities. UMLDiff and the analyses it enables can assist software engineers in their tasks of understanding the rationale of design evolution of the software system and planning future development and maintenance activities. We evaluate UMLDiff's correctness and robustness through a real-world case stud.

Organizations that own Web services participating in a workflow composition may evolve their components independently. Service coordination can fail when previously legal messages between independently changing, distributed components become illegal because their respective workflow models are no longer synchronized. This paper presents an intelligent-agent framework that wraps a Web service in a conversation layer and a simple workflow-adaptation function. The conversation layer implements protocols and consults globally shared, declarative policy specifications to resolve interaction failures. The framework allows agents to resolves various model mismatches that cause interaction errors, including changes to required preconditions, partners, and expected message ordering. Implications of this distributed approach to Web service coordination are also discussed.

The web-services stack of standards is designed to support the reuse and interoperation of software components on the web. A critical step in the process of developing applications based on web services is service discovery, i.e. the identification of existing web services that can potentially be used in the context of a new web application. Discovery through catalog-style browsing (such as supported currently by web-service registries) is clearly insufficient. To support programmatic service discovery, we have developed a suite of methods that assess the similarity between two WSDL (Web Service Description Language) specifications based on the structure of their data types and operations and the semantics of their natural language descriptions and identifiers. Given only a textual description of the desired service, a semantic information-retrieval method can be used to identify and order the most relevant WSDL specifications based on the similarity of the element descriptions of the available specifications with the query. If a (potentially partial) specification of the desired service behavior is also available, this set of likely candidates can be further refined by a semantic structure-matching step, assessing the structural similarity of the desired vs the retrieved services and the semantic similarity of their identifiers. In this paper, we describe and experimentally evaluate our suite of service-similarity assessment methods.

Today, most object-oriented software systems are developed using an evolutionary process model. Therefore, understanding the phases that the system's logical design has gone through and the style of their evolution can provide valuable insights in support of consistently maintaining and evolving the system, without compromising the integrity and stability of its architecture. In this paper, we present a method for analyzing the evolution of object-oriented software systems from the point of view of their logical design. This method relies on UMLDiff, a UML-structure differencing algorithm, which, given a sequence of UML class models corresponding to the logical design of a sequence of system code releases, produces a sequence of "change records" that describe the design-level changes between subsequent system releases. This change-records sequence is subsequently analyzed from the perspective of each individual system class, to produce the class-evolution profile, i.e., a class-specific change-records' sequence. Three types of longitudinal analyses - phasic, gamma, and optimal matching analysis - are applied to the class-evolution profiles to recover a high-level abstraction of distinct evolutionary phases and their corresponding styles and to identify class clusters with similar evolution trajectories. The recovered knowledge facilitates the overall understanding of system evolution and the planning of future maintenance activities. We report on one real-world case study evaluating our approach.

Understanding the phases and styles of evolution of software systems can provide valuable insight in support of project management. We present a method for studying the evolution of object-oriented software at system/subsystem level and analyzing the underlying factors that drive its unfolding over time. This method relies on analyzing the design-level structural changes between two subsequent software versions to identify additions, removals, moves, renamings and signature-changes of classes, interfaces, and their methods and fields, represented as change trees. A sequence of such change trees constitutes the system's evolution profile. Based on discrete system evolution profiles, three types of analyses: phasic analysis, gamma analysis, and optimal matching analysis, are applied, to abstract an overall sequential pattern and structural properties of system evolution phases and to develop the typology of system evolution styles. We report on two case studies evaluating our approach.

Abstract The number of Web users and the diversity of their interests increase continuously; Web‐content providers seek to infer these interests and to adapt their Web sites to improve accessibility of the offered content. Usage‐pattern mining is a promising approach in support of this goal. Assuming that past navigation behavior is an indicator of the users' interests, then, Web‐server logs can be mined to infer what the users are interested in. On that basis, the Web site may be reorganized to make the interesting content more easily accessible or recommendations can be dynamically generated to help new visitors find information of interest faster. In this paper, we discuss a case study examining the effectiveness of sequential‐pattern mining for understanding the users' navigation behavior in focused Web sites. This study examines the Web site of an undergraduate course, as an example of a focused Web site that offers information intrinsically related to a process and closely reflects the workflow of this underlying process. We found that in such focused sites, indeed, visitor behavior reflects the process supported by the Web site and that sequential‐pattern mining can effectively predict Web‐usage behavior in these sites. Copyright © 2004 John Wiley & Sons, Ltd.

Todays teaching and learning practices are evolving to leverage the continuously increasing information available on the web, on all conceivable subject matters. This wealth of information presents a great challenge: how to provide an integrated, authoritative, extendible and shareable information collection of related multimedia education materials. In this paper, we describe EduNuggets (http://www.cs.ualberta.ca/~stroulia/EduNuggets), our intelligent repository for multimedia educational materials.

The Web-services stack of standards is designed to support the reuse and interoperation of software components on the Web. A critical step, to that end, is service discovery, i.e., the identification of existing Web services that can potentially be used in the context of a new Web application. UDDI, the standard API for publishing Web-services specifications, provides a simple browsing-by-business-category mechanism for developers to review and select published services. In our work, we have developed a flexible service discovery method, for identifying potentially useful services and assessing their relevance to the task at hand. Given a textual description of the desired service, a traditional information-retrieval method is used to identify the most similar service description files, and to order them according to their similarity. Next, given this set of likely candidates and a (potentially partial) specification of the desired service behavior, a structure-matching step further refines and assesses the quality of the candidate service set. In this paper, we describe and experimentally evaluate our Web-service discovery process.

A plethora of information and services is available on the World Wide Web; the challenge has now become to enable the interoperation of these services in the context of high-quality, integrated applications, providing personalized value-added services to the end user. TaMeX is a software framework that supports the development of intelligent multiagent applications, integrating services of existing web applications. The TaMeX applications rely on a set of specifications of the domain model, the integration workflow, their semantic constraints, the end-user profiles, and the services of the existing web applications; all these models are declaratively represented in the XML-based TaMeX integration-specification language. At run-time, the TaMeX agents use these models to flexibly interact with the end users, monitor and control the execution of the underlying applications' services and coordinate the information exchange among them, and to collaborate with each other to react to failures and effectively accomplish the desired user request. In this paper, we describe the TaMeX framework and we illustrate its capabilities with an integrated book-finding application as a case study.

In the context of the CelLEST project, we have been investigating the problem of reengineering and reusing the services provided by legacy applications, running on mainframe hosts. This work has resulted in a suite of methods, based on understanding and modeling the users' interaction with the legacy-application interface. These methods aim at (a) modeling the behavior of the legacy user interface as a state-transition diagram, (b) recovering specifications for the application's functions by discovering the users' tasks as frequently occurring interaction patterns, and (c) constructing new user-interface front-ends to make the recovered legacy functions accessible through the Web. We describe the overall process for legacy migration to the World Wide Web, using the CelLEST methods, and we illustrate it with an example case study.

A key challenge facing IT organizations today is their evolution towards adopting e-business practices that gives rise to the need for reengineering their underlying systems. Any reengineering effort has to be aware of the functional requirements of the subject system, in order not to violate the integrity of its intended uses. However, as systems get regularly maintained throughout their lifecycle, the documentation of their requirements often become obsolete or get lost. To address this problem of software requirements loss, we have developed an interaction-pattern mining method for the recovery of functional requirements as usage scenarios. Our method analyzes traces of the run-time system-user interaction to discover frequently recurring patterns; these patterns correspond to the functionality currently exercised by the system users, represented as usage scenarios. The discovered scenarios provide the basis for reengineering the system into web-accessible components, each one supporting one of the discovered scenarios. In this paper, we describe IPM2, our interaction-pattern discovery algorithm, we illustrate it with a case study from a real application and we give an overview of the reengineering process in the context of which it is employed.

As software systems age, the requirements that motivated their original development get lost. Requirements documentation is unavailable or obsolete. Recapturing these requirements is critical for software reengineering activities. In our CelLEST process we adopt a data-mining approach to this problem and attempt to discover patterns of frequent similar episodes in the sequential run-time traces of the legacy user-interface behavior. These patterns constitute operational models of the application's functional requirements, from the end-user perspective. We have developed an algorithm, IPM, for interaction-pattern discovery. This algorithm discovers patterns that meet a user-specified criterion and is robust to insertion errors, caused by user mistakes or by the availability of alternative scenarios for the same user task. In this paper, we discuss IPM and we evaluate it with a case study.

In this paper, we discuss Babel, a prototype tool for integrating multiple heterogeneous applications, by wrapping them and by specifying the logic of their interoperation in XML.

No abstract available.

Waste cleanup is a task which occurs in a great variety of domains and contexts. In spite of the variety of the causes and the types of waste, cleaning it up typically involves dirty, dull, strenuous and sometimes hazardous actions. Thus waste cleanup constitutes a natural task for service robots. In this paper, we describe an office robot, DAVID, who in addition to collecting and delivering mail and stationary, cleans up offices from garbage. We describe, the system's flexible functional architecture and its various components. We identify some functionalities critical in waste-cleanup tasks and describe how they are accomplished in DAVID. The paper closes with the discussion of an experiment which demonstrates the performance of the system, and with a set of conclusions we drew from this work.