Trapped-Ion (TI) technology offers potential breakthroughs for Noisy Intermediate Scale Quantum (NISQ) computing. TI qubits offer extended coherence times and high gate fidelity, making them appealing for large-scale NISQ computers. Constructing such computers demands a distributed architecture connecting Quantum Charge Coupled Devices (QCCDs) via quantum matter-links and photonic switches. However, current distributed TI NISQ computers face hardware and system challenges. Entangling qubits across a photonic switch introduces significant latency, while existing compilers generate suboptimal mappings due to their unawareness of the interconnection topology. In this paper, we introduce TITAN, a large-scale distributed TI NISQ computer, which employs an innovative photonic interconnection design to reduce entanglement latency and an advanced partitioning and mapping algorithm to optimize matter-link communications. Our evaluations show that TITAN greatly enhances quantum application performance by 56.6% and fidelity by 19.7% compared to existing systems.

Engineering green software-intensive systems is critical in our drive towards a sustainable, smarter planet. The goal of green software engineering is to apply green principles to the design and operation of software-intensive systems. Green and self-greening software systems have tremendous potential to decrease energy consumption. Moreover, enterprise software can and should be re-thought to address sustainability issues using innovative business models, processes, and incentives. Monitoring and measuring the greenness of software is critical towards the notion of sustainable and green software. Demonstrating improvement is paramount for users to achieve and affect change. Thus, the theme of GREENS 2015 is Towards a Green Software Body of Knowledge. The GREENS workshop series brings together researchers and practitioners to discuss both the state-of-the-art and state-of-the-practice in green software, including novel ideas, research challenges, methods, experiences, and tools to support the engineering of sustainable and energy efficient software systems.

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.

Users utilize web applications to perform everyday tasks in order to achieve personal goals. Personalized Web-Tasking (PWT) is the automation of such web interactions while exploiting personal context to enrich users experience. However, web-tasking is affected by unpredictable context behaviour -- environment, user, and infrastructure -- and situational changes. Given that current web systems are challenged to respond effectively to such changes, we proposed to design PWT applications as self-adaptive software systems that exploit personal context to deliver user-centric functionalities. This paper presents our first approach implementing PWT applications using a grocery shopping web-tasking scenario. Our prototype PWT system transforms web-tasking knowledge information (i.e., user's web interactions) into RDF graphs (i.e., runtime models that contain the user's web-tasking). We conclude our paper with a discussion about our results and implementation challenges.

This position paper illustrates applications of a context-based face recognition system for smart web tasking. Context-based face recognition can provide a personalized service based on recognition face and derived context information. Using selected smart applications, we show how context-based face recognition system could help deliver personalized services.

No abstract available.

ICT accounts for approximately 2% of world CO2 emissions, a figure equivalent to aviation, according to Gartner estimates. In the remaining 98% software counts for both operationalizing the private sector in doing its business and the public sector in supporting the society, as well as delivering enduser applications that permeate personal life of individuals and families. Software can contribute to decrease power consumption (i.e., become greener) in at least two ways. First, by being more energy efficient, hence using fewer resources and causing fewer CO2 emissions. Second, by making its processes more sustainable, i.e. decreasing the emissions of governments, companies and individuals. To this end, enterprise software must be rethought to address sustainability issues and support innovative business models and processes. The special theme of the second edition of GREENS is “Leveraging energy efficiency to software users”. This workshop brings together software engineering researchers and practitioners to discuss the state-of-the-art and state-of-the-practice in green software, as well as research challenges, novel ideas, methods, experiences, and tools to support the engineering of sustainable and energy efficient software systems.

Despite the increasing use of the web to support human activities, most web interactions required to accomplish personal goals are performed manually by users. Even though users can easily transform a goal into multiple web interactions, the manual governance of these interactions diminishes the user experience. Personalized web-tasking seeks to improve the user experience by automating personal web tasks. This automation is driven by user needs, matters of concerns, and personal context. An important concern in personalized web-tasking is task simplification, the process of decomposing a personal web task into simpler tasks that can readily be composed into bigger tasks. This position paper characterizes a set of task simplification challenges intended as starting points for advancing the field of personalized web-tasking.

With the constant evolution of the Internet, a repetitive and ordinary task such as searching online resources has become more complex due to the amount of web services and formats available (e.g., video, audio, text or images). In order to obtain resources within a specific domain, a user manually performs several tasks, such as navigating through different web services, filtering according to various criteria and selecting the relevant results. However, the insufficient contextual information of the underlying application hampers the user's experience. In this paper, we propose a tool to improve a user's experience by automating the task of retrieving interesting resources in a multi user setting. We apply this approach to a chat scenario where users are exposed to resources that are of common interests by exploiting the users' personal context information.

Mobile devices offer an unprecedented amount of context about their users. Management of this context is like trying to find the signal in the noise. Those applications that can find the signal open themselves up to new business opportunities. These business opportunities come about as a result of emergent behavior and are better at satisfying user utility. Applications need to become smart applications and as software engineers we can make this happen by looking at the lessons learned from self-adaptive systems. Data structures, models, and an unfettered resolve to simplifying the user experience will help us get there.

Distributed systems require effective mechanisms to manage the reliable provisioning of computational resources from different and distributed providers. Moreover, the dynamic environment that affects the behaviour of such systems and the complexity of these dynamics demand autonomous capabilities to ensure the behaviour of distributed scheduling platforms and to achieve business and user objectives. In this paper we propose a self-adaptive distributed scheduling platform composed of multiple agents implemented as intelligent feedback control loops to support policy-based scheduling and expose self-healing capabilities. Our platform leverages distributed scheduling processes by (i) allowing each provider to maintain its own internal scheduling process, and (ii) implementing self-healing capabilities based on agent module recovery. Simulated tests are performed to determine the optimal number of agents to be used in the negotiation phase without affecting the scheduling cost function. Test results on a real-life platform are presented to evaluate recovery times and optimize platform parameters.

The Software Engineering for Adaptive and Self-managing Systems (SEAMS) workshop has consolidated the interest in the software engineering community on self-adaptive and self-managing systems. SEAMS provides a forum for researchers and practitioners to share new results, discuss challenging issues, raise awareness, and promote collaboration within the community. The SEAMS 2010 workshop aims to continue the success of previous ICSE SEAMS workshops: in Shanghai in 2006, in Minneapolis in 2007, in Leipzig in 2008, and in Vancouver in 2009.

The challenge and prospect of becoming a new teaching faculty member at a research university is one that most people accept with enthusiasm and energy, but also with some trepidation: • How do I get a position? • How do I get to develop and publish strong research results? • How will I be able to balance the many aspects of work as well as my personal life? • What is my academic path to tenure and beyond?

The two papers in this special section are extended and enhanced versions of ones presented at the International Conference on Software Maintenance (ICSM), held in Paris, France, on 2-5 October 2007.

The objective of the 2nd international workshop on advanced software development tools and techniques (WASDeTT) is to provide interested researchers with a forum to share their tool building experiences and to explore how tools can be built more effectively and efficiently. This workshop specifically focuses on tools for software maintenance and comprehension and addresses issues such as tool-building in an industrial context, component-based tool building, and tool building in teams.

We have developed a fully-featured graph editor based on scalable vector graphics (SVG) that can be customized for different application domains. Our SVG editor is an interactive SVG document (implemented in JavaScript) that can be embedded into other applications such as web browsers and office suites. As a result, maintenance documents now can be interactively explored, more easily integrated, and automatically kept in sync with the underlying data source.

Autonomic computing has become more prevalent in recent years for its vision of developing applications with self-adaptive and self-managing behavior. Due to the inherent complexity of such applications and the nature of the built-in closed-loop feedback control, maintainability issues of autonomic systems are emerging as significant concerns in autonomic system designs. This paper identifies and categorizes types of common forms of autonomic element patterns and reveals the inherent relationships among them as well as their particular maintainability concerns. The key to maintainability of self-managing systems is their embedded control loops. Good software engineering practice calls for making the control loops as independent as possible to achieve loose coupling and separate concerns. However, typical self-managing systems solutions feature arrangements of interdependent, collaborative autonomic elements. This paper outlines selected autonomic element patterns derived from requirements goal models and attribute-based architectural styles for self-adaptive systems and then identifies their particular maintainability concerns based on the characteristics of the solutionpsilas control loops. Maintainability issues for the various autonomic element patterns are illustrated using a book store example.

The objective of this workshop is to consolidate the interest in the software engineering community on autonomic, self-managing, self-healing, self-optimizing, self-configuring, and self-adaptive systems. The workshop will provide a forum for researchers to share new results, raise awareness of new adaptive concerns, and promote collaboration among the community. This workshop will be the first of several to assess progress and identify challenges in this important area.

Understanding software engineering issues for autonomic computing systems is critical for the software and information technology sectors, which are continually challenged to reduce the complexity of their systems. To be autonomic, a system must know itself as well as its boundaries and its environment, configure and reconfigure itself, continually optimize itself, recover or heal from malfunction, protect itself, and function in a heterogeneous world-while keeping its complexity hidden from the user. The goal of this workshop is to bring together researchers and practitioners, who investigate concepts, methodologies, techniques, technologies, and tools to design and evolve autonomic software.

Abstract This paper provides a balanced perspective of the business value and technical challenges of adopting Web services. Technology adoption is a continual challenge for both tool developers and enterprise users. Web services are a prime example of an emerging technology that is fraught with adoption issues. Part of the problem is separating marketing hype from business reality. Web services are network‐accessible interfaces to application functionality. They are built using Internet technologies such as XML and standard protocols such as SOAP. The adoption issues related to Web services are complex and multifaceted. For example, determining whether this technology is a fundamental advance, rather than something old under a new name, requires technical depth, business acumen, and considerable historical knowledge of past developments. A sample problem from the health care industry is used to illustrate some of the adoption issues. Copyright © 2004 John Wiley & Sons, Ltd.

The key objective of this workshop is to explore innovative approaches to the adoption of software engineering tools and practices-in particular by embedding them in extensions of Commercial Off-The-Shelf (COTS) software products and/or middleware technologies. The workshop aims to advance the understanding and evaluation of adoption of software engineering tools and practices by bringing together researchers and practitioners who investigate novel solutions to software engineering adoption issues.

The demand for continuous service in mission- and safety-critical software applications is increasing. For these applications, it is unacceptable to shutdown and restart the system during software upgrade. This paper examines issues relating to on-line upgrades for mission- and safety-critical software applications. We believe that a dynamic architecture and communication model provides an excellent foundation for runtime software evolution. To solve the problems mentioned above, we designed and implemented a framework, which addresses four main areas: dynamic architecture and communication model, reconfiguration management, the upgrade protocol, and the upgrade technique. The framework can be used for online upgrading of multi-task software applications, which provide multiple mission-critical services. In the framework discussed in the paper, the ability to make runtime modifications is considered at the software architecture-level. The dynamic architecture and communication model makes it possible for software applications to add, remove, and hot swap modules on the fly. The transition scenario is specified by the upgrade protocol. The framework also provides the mechanism for maintaining state consistency. In order to ensure a reliable upgrade, a two-phase commit protocol is utilized to implement the atomic upgrade transactions. In addition, a command line interface facilitates the reconfiguration management. A simulation study of the proposed framework was carried out for live software upgrade of several practical applications. The results of the simulation are also presented.

The paper describes the integration of information sources to support the exploration of source code and documentation of Java programs. There are many public domain tools that are available for extracting information and documentation from Java programs. We describe how data integration and presentation integration were used to enable the visualization of this information within a software exploration environment.

Abstract Shimba is a reverse engineering environment to support the understanding of Java software systems. Shimba integrates the Rigi and SCED tools to analyze and visualize the static and dynamic aspects of a subject system. The static software artifacts and their dependencies are extracted from Java byte code and viewed as directed graphs using the Rigi reverse engineering environment. The run‐time information is generated by running the target software under a customized SDK debugger. The generated information is viewed as sequence diagrams using the SCED tool. In SCED, statechart diagrams can be synthesized automatically from sequence diagrams, allowing the user to investigate the overall run‐time behavior of objects in the target system. Shimba provides facilities to manage the different diagrams and to trace artifacts and relations across views. In Shimba, SCED sequence diagrams are used to slice the static dependency graphs produced by Rigi. In turn, Rigi graphs are used to guide the generation of SCED sequence diagrams and to raise their level of abstraction. We show how the information exchange among the views enables goal‐driven reverse engineering tasks and aids the overall understanding of the target software system. The FUJABA software system serves as a case study to illustrate and validate the Shimba reverse engineering environment. Copyright © 2001 John Wiley & Sons, Ltd.

Article Free Access Share on CHIME: customizable hyperlink insertion and maintenance engine for software engineering environments Authors: P. Devanbu Dept. of Computer Science, University of California, Davis, CA Dept. of Computer Science, University of California, Davis, CAView Profile , Y.-F. Chen AT&T Labs-Research, 190, Park Drive, Florham Park, NJ AT&T Labs-Research, 190, Park Drive, Florham Park, NJView Profile , E. Gansner AT&T Labs-Research, 190, Park Drive, Florham Park, NJ AT&T Labs-Research, 190, Park Drive, Florham Park, NJView Profile , H. Müller Dept. Of Computer Science, University of Victoria, Victoria, BC Dept. Of Computer Science, University of Victoria, Victoria, BCView Profile , J. Martin Dept. Of Computer Science, University of Victoria, Victoria, BC Dept. Of Computer Science, University of Victoria, Victoria, BCView Profile Authors Info & Claims ICSE '99: Proceedings of the 21st international conference on Software engineeringMay 1999 Pages 473–482https://doi.org/10.1145/302405.302679Published:16 May 1999Publication History 17citation305DownloadsMetricsTotal Citations17Total Downloads305Last 12 Months20Last 6 weeks2 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF

No abstract available.

No abstract available.

There are two basic approaches to migrating a particular subsystem: reengineering and wrapping. The author considers coarse-grained object wrapping. In wrapping, the original subsystem is essentially integrated into the new setting using infrastructure technologies. Legacy systems that have evolved over many years are notoriously difficult to decompose. Wrapping is most effective if the legacy system can be decomposed into a few large chunks where the number of communication paths among subsystems is minimized. The author discusses the use of infrastructure technology such as CORBA (Common Object Request Broker Architecture)

An effective approach to program understanding involves browsing, exploring, and creating views that document software structures at different levels of abstraction. While exploring the myriad of relationships in a multi-million line legacy system, one can easily loose context. One approach to alleviate this problem is to visualize these structures using fisheye techniques. This paper introduces Simple Hierarchical Multi-Perspective views (SHriMPs). The SHriMP visualization technique has been incorporated into the Rigi reverse engineering system. This greatly enhances Rigi's capabilities for documenting design patterns and architectural diagrams that span multiple levels of abstraction. The applicability and usefulness of SHriMPs is illustrated with selected program understanding tasks.

Program understanding can be enhanced using reverse engineering technologies. The understanding process is heavily dependent on both individuals and their specific cognitive abilities, and on the set of facilities provided by the program understanding environment. Unfortunately, most reverse engineering tools provide a fixed palette of extraction, selection, and organization techniques. This paper describes a programmable approach to reverse engineering. The approach uses a scripting language that enables users to write their own routines for common reverse engineering activities, such as graph layout, metrics, and subsystem decomposition, thereby extending the capabilities of the reverse engineering toolset to better suit their needs. A programmable environment supported by this approach subsumes existing reverse engineering systems by being able to simulate facets of each one.

A user programmable approach to reverse engineering is described. The approach uses a scripting language that enables users to write their own routines for these activities, making the system domain-retargetable. The environment supported by this programmable approach subsumes existing reverse engineering systems by being able to simulate facets of each one and provides a smooth transition from semi-automatic to automatic reverse engineering.>

Abstract Reverse‐engineering is the process of extracting system abstractions and design information out of existing software systems. This process involves the identification of software artefacts in a particular subject system, the exploration of how these artefacts interact with one another, and their aggregation to form more abstract system representations that facilitate program understanding. This paper describes our approach to creating higher‐level abstract representations of a subject system, which involves the identification of related components and dependencies, the construction of layered subsystem structures, and the computation of exact interfaces among subsystems. We show how top‐down decompositions of a subject system can be (re)constructed via bottom‐up subsystem composition. This process involves identifying groups of building blocks (e.g., variables, procedures, modules, and subsystems) using composition operations based on software engineering principles such as low coupling and high cohesion. The result is an architecture of layered subsystem structures. The structures are manipulated and recorded using the Rigi system, which consists of a distributed graph editor and a parsing system with a central repository. The editor provides graph filters and clustering operations to build and explore subsystem hierarchies interactively. The paper concludes with a detailed, step‐by‐step analysis of a 30‐module software system using Rigi.

The authors describe a clustering method that uses equivalence relations for identifying subsystem structures. The relations are intended to embody the software engineering principles that concern module interactions, such as low coupling, high strength, small interfaces, and few interfaces. The resulting compositions are (k,2)-partite graphs (a class of layered graphs) rather than strict tree hierarchies. The method is supported by an interactive graph editor.>