Advances in technologies like artificial intelligence and metaverse have led to a proliferation of software systems in business and everyday life. With this widespread penetration, the carbon emissions of software are rapidly growing as well, thereby negatively impacting the long-term sustainability of our environment. Hence, optimizing software from a sustainability standpoint becomes more crucial than ever. We believe that the adoption of automated tools that can identify energy-inefficient patterns in the code and guide appropriate refactoring can significantly assist in this optimization. In this extended abstract, we present an industry case study that evaluates the sustainability impact of refactoring energy -inefficient code patterns identified by automated software sustainability assessment tools for a large application. Preliminary results highlight a positive impact on the application's sustainability post-refactoring, leading to a 29% decrease in per-user per-month energy consumption.

With the climate crisis looming, engineering sustainable software systems become crucial to optimize resource utilization, minimize environmental impact, and foster a greener, more resilient digital ecosystem. For developers, getting access to automated tools that analyze code and suggest sustainability-related optimizations becomes extremely important from a learning and implementation perspective. However, there is currently a dearth of such tools due to the lack of standardized knowledge, which serves as the foundation of these tools. In this paper, we motivate the need for the development of a standard knowledge base of commonly occurring sustainability weaknesses in code, and propose an initial way of doing that. Furthermore, through preliminary experiments, we demonstrate why existing knowledge regarding software weaknesses cannot be re-tagged “as is” to sustainability without significant due diligence, thereby urging further explorations in this ecologically significant domain.

Recent breakthroughs in Large Language Models (LLM), comprised of billions of parameters, have achieved the ability to unveil exceptional insight into a wide range of Natural Language Processing (NLP) tasks. The onus of the performance of these models lies in the sophistication and completeness of the input prompt. Minimizing the enhancement cycles of prompt with improvised keywords becomes critically important as it directly affects the time to market and cost of the developing solution. However, this process inevitably has a trade-off between the learning curve/proficiency of the user and completeness of the prompt, as generating such a solutions is an incremental process. In this paper, we have designed a novel solution and implemented it in the form of a plugin for Visual Studio Code IDE, which can optimize this trade-off, by learning the underlying prompt intent to enhance with keywords. This will tend to align with developers' collection of semantics while developing a secure code, ensuring parameter and local variable names, return expressions, simple pre and post-conditions. and basic control and data flow are met.

As the world takes cognizance of AI's growing role in greenhouse gas(GHG) and carbon emissions, the focus of AI research & development is shifting towards inclusion of energy efficiency as another core metric. Sustainability, a core agenda for most organizations, is also being viewed as a core non-functional requirement in software engineering. A similar effort is being undertaken to extend sustainability principles to AI-based systems with focus on energy efficient training and inference techniques. But an important question arises, does there even exist any metrics or methods which can quantify adoption of “green” practices in the life cycle of AI-based systems? There is a huge gap which exists between the growing research corpus related to sustainable practices in AI research and its adoption at an industry scale. The goal of this work is to introduce a methodology and novel metric for assessing “greenness” of any AI-based system and its development process, based on energy efficient AI research and practices. The novel metric, termed as Green AI Quotient, would be a key step towards AI practitioner's Green AI journey. Empirical validation of our approach suggest that Green AI Quotient is able to encourage adoption and raise awareness regarding sustainable practices in AI lifecycle.

Autonomous agents equipped with Large Language Models (LLMs) are rapidly gaining prominence as a revolutionary technology within the realm of Software Engineering. These intelligent and autonomous systems demonstrate the capacity to perform tasks and make independent decisions, leveraging their intrinsic reasoning and decision-making abilities. This paper delves into the current state of autonomous agents, their capabilities, challenges, and opportunities in Software Engineering practices. By employing different prompts (with or without context), we conclude the advantages of contextrich prompts for autonomous agents. Prompts with context enhance user requirement understanding, avoiding irrelevant details that could hinder task comprehension and degrade model performance, particularly when dealing with complex frameworks such as Spring Boot, Django, Flask, etc. This exploration is conducted using Auto-GPT (v0.3.0), an open-source application powered by GPT-3.5 and GPT-4 which intelligently connects the “thoughts” of Large Language Models (LLMs) to independently accomplish the assigned goals or tasks.

Energy efficiency has become an important consideration in deep learning systems. However, it remains a largely under-emphasized aspect during the development. Despite the emergence of energy-efficient deep learning patterns, their adoption remains a challenge due to limited awareness. To address this gap, we present DENT (Deep Learning Energy Pattern Tagger, a Chrome extension used to add "energy pattern tags" to the deep learning related questions from Stack Overflow. The idea of DENT is to hint to the developers about the possible energy-saving opportunities associated with the Stack Overflow post through energy pattern labels. We hope this will increase awareness about energy patterns in deep learning and improve their adoption. A preliminary evaluation of DENT achieved an average precision of 0.74, recall of 0.66, and an F1-score of 0.65 with an accuracy of 66%. The demonstration of the tool is available at https://youtu.be/S0Wf_w0xajw and the related artifacts are available at https://rishalab.github.io/DENT/

The exponential rise of deep learning, aided by the availability of several frameworks and specialized hardware, has led to its application in a wide variety of domains. The availability of GPUs has made it easier to train networks with a huge number of parameters. However, this rise has come at the expense of ever-increasing energy requirements and carbon footprint. While the existing work tries to combat this issue by proposing optimizations in the hardware and the neural network architectures, there is an absence of general energy efficiency guidelines for deep learning developers. In this paper, we propose an initial catalog of 8 energy patterns for developing deep learning applications by analyzing 1361 posts from Stack Overflow. Our hope is that these energy patterns may help the developers adopt energy efficient practices in their deep learning projects. A survey with 14 deep learning developers showed us that the developers are largely in agreement with the usefulness of the catalog from an energy efficiency perspective. A detailed description of the catalog, along with the posts related to each energy pattern, is available at the following link: https://rishalab.github.io/dl_energy_patterns/

Energy efficiency is an essential consideration in mobile application development, given that these apps run on battery-powered devices. This has led the researchers to develop a set of energy design patterns that can help the developers improve the energy efficiency of their applications. However, the adoption of these energy patterns in projects remains a challenge, given the lack of awareness about these patterns among the developers. To bridge this gap, we propose our tool eTagger, a Google Chrome extension that tags GitHub issues from Android repositories with associated energy patterns. eTagger works based on the embeddings generated by Sentence-BERT. We believe that labeling the GitHub issues with energy patterns may help towards their larger adoption as GitHub is a prominent platform in collaborative software development. A preliminary evaluation of eTagger achieved an AUC-ROC of 0.73 with a precision of 0.58, recall of 0.53 and an F1-score of 0.5. The demonstration of the tool is available at https://youtu.be/hP4pWJ4AKxE and related artifacts at https://rishalab.github.io/eTagger/.

Sustainable software engineering has received a lot of attention in recent times, as we witness an ever-growing slice of energy use, for example, at data centers, as software systems utilize the underlying infrastructure. Characterizing servers for their energy use accurately without being intrusive, is therefore important to make sustainable software deployment choices. In this paper, we introduce ESAVE which is a machine learning-based approach that leverages a small set of hardware attributes to characterize a server or virtual machine’s energy usage across different levels of utilization. This is based upon an extensive exploration of multiple ML approaches, with a focus on a minimal set of required attributes, while showcasing good accuracy. Early validations show that ESAVE has only around 12% average prediction error, despite being non-intrusive.

While traditionally, software comprehension relies on approaches like reading through the code or looking at charts on screens, which are 2D mediums, there have been some recent approaches that advocate exploring 3D approaches like Augmented or Virtual Reality (AR/VR) to have a richer experience towards understanding software and its internal relationships. However, there is a dearth of objective studies that compare such 3D representations with their traditional 2D counterparts in the context of software comprehension. In this paper, we present an evaluation study to quantitatively and qualitatively compare 2D and 3D software representations with respect to typical comprehension tasks. For the 3D medium, we utilize an AR-based approach for 3D visualizations of a software system (XRaSE), while the 2D medium comprises of textual IDEs and 2D graph representations. The study, which has been conducted using 20 professional developers, shows that for most comprehension tasks, the developers perform much better using the 3D representation, especially in terms of velocity and recollection, while also displaying reduced cognitive load and better engagement.

Large IT organizations depend on a global software delivery model which involves large teams with various roles and stakeholders. As software delivery is inherently collaborative, it requires the different roles to share artifacts, knowledge and insights with each other throughout the delivery life-cycle. Typically, each role has different insight and understanding needs, based on her/his context and activities. An architect may need to understand the system from a modularity perspective, a developer from code quality purposes, whereas a tester would need to understand it from a user-triggered flow perspective. However, the way we represent, understand, and collaborate on software artefacts, is still limited by the confines of traditional 2D computer screens. In this paper, we present our early work of an Extended Reality (XR) based approach that leverages affordances of natural human perception to represent and visualize software applications in three dimensions. This immersive approach is aimed at becoming a common fabric across global delivery roles, making activities like application comprehension, architecture analysis, knowledge communication, and analysis of a software's dynamic aspects, more contextual, richer, and intuitive. We posit that the use of XR, specifically augmented/mixed reality-based multidimensional views of different software artefacts, can be adapted to be an intuitive bridge across different roles, and foster a novel way of collaboration (both locally and globally). Here, we present our immersive approach and its prototype implementation, along with examples of its usage by different project roles. We also discuss some early feedback and the way forward.

Software engineering has seen much progress in recent past including introduction of new methodologies, new paradigms for software teams, and from smaller monolithic applications to complex, intricate, and distributed software applications. However, the way we represent, discuss, and collaborate on software applications throughout the software development life cycle is still primarily using the source code, textual representations, or charts on 2D computer screens - the confines of which have long limited how we visualize and comprehend software systems. In this paper, we present XRaSE, a novel prototype implementation that leverages augmented reality to visualize a software application as a virtually tangible entity. This immersive approach is aimed at making activities like application comprehension, architecture analysis, knowledge communication, and analysis of a software's dynamic aspects, more intuitive, richer and collaborative.

For delivering high-quality artifacts within the budget and on schedule, software delivery teams ideally should have a holistic and in-process view of the current health and future trajectory of the project. However, such insights need to be at the right level of granularity and need to be derived typically from a heterogeneous project environment, in a way that helps development team members with their tasks at hand. Due to client mandates, software delivery project environments employ many disparate tools and teams tend to be distributed, thus making the relevant information retrieval, insight generation, and developer intelligence augmentation process fairly complex. In this paper, we discuss our journey in this area spanning across facets like software project modelling and new development metrics, studying developer priorities, adoption of new metrics, and different approaches of developer intelligence augmentation. Finally, we present our exploration of new immersive technologies for human-centered software engineering.

Human activities can have a lasting impact on the environment and society. Environmental impact assessment (EIA) which focusses on evaluating the impact of proposed developmental projects on the environment, helps in transparent decision-making and involves multiple stakeholders. However, EIA is data and effort-intensive and often becomes complex and long-drawn. Moreover, EIA is currently performed using primarily two-dimensional traditional mediums which could be vastly restrictive and difficult to navigate and comprehend. Here, we present an immersive approach which can create 3D interactive elements, modelling the real-world using augmented/mixed reality. Because of the inherent benefits of using three-dimensional representations and associated real-world interactions, we posit that our approach will facilitate better and faster, collaboration-enabled analysis of a developmental project proposal, thereon reducing processing time and promoting high fidelity.

Agile software development approaches are becoming mainstream as organizations recognize that their delivery methodology has to be nimble and flexible to accommodate new technologies and evolving customer requirements. However, large organizations depend on a global software delivery model wherein software teams are geographically distributed, and such an environment seems unsuited for Agile to succeed. In such scenarios, it is a challenge to be able to bring together the organization's Agile methodology, development environment, and distributed teams together in a standardized way, to be able to implement and govern the distributed delivery process objectively. Here, we present our approach to govern the adoption, usage and progress thereof of a distributed Agile methodology, that ties together the team and tool aspects with it. This becomes a single window to quickly bootstrap distributed Agile delivery projects using specific methods, metrics and dashboards, collaboration and gamification approaches. We have implemented this approach as an interactive Agile Workbench to present the teams and stakeholders with context-rich actionable alerts as well as situational awareness and helps bridge the gaps between cross-functional distributed teams which is essential to successful delivery of agile projects.

Applications have evolved significantly over time - from monolithic and self contained, to numerous plug gable apps available on various platforms these days. Modern applications their functionality as services in varying level of granularity and domains. This paradigm of Everything as a Service (XaaS), provides a dynamic environment wherein multiple smaller applications can be rapidly composed to create complex applications. Such composite applications would allow for efficient re-use of the existing applications and their services, instead of more traditional model of building everything from scratch. The intent of this paper is to demonstrate our initial work to implement an end-to-end delivery system in an enterprise scenario. We propose an automated algorithm to utilize a composer's input to match available services and create a composite plan or a manifest which is then used to quickly orchestrate the composite application in real-time. We have implemented our approach on our internal enterprise cloud using Puppet.

As we move to the next generation of networks such as Internet of Things (IoT), the amount of data generated and stored on the cloud is going to increase by several orders of magnitude. Traditionally, storage or middleware layer encryption has been used for protecting data at rest. However, such mechanisms are not suitable for cloud databases. More sophisticated methods include user-layer-encryption (ULE) (where the encryption is performed at the end-user's browser) and application-layer-encryption (ALE) (where the encryption is done within the web-app). In this paper, we study security and functionality aspects of cloud encryption and present an ALE framework for Java called JADE that is designed to protect data in the event of a server compromise.

Different PaaS (Platform as a Service) Clouds offer different set of capabilities and services and have different constraints on types of application that can be hosted on their platforms. Migrating existing enterprise applications to such platforms thus is non-trivial and needs a thorough assessment of the system to be migrated. In this paper, we present a novel approach for automated assessment of applications for migration to a target PaaS platform. We take an approach of systematically studying typical external technical services that different types of applications need in a traditional non-PaaS deployment and evaluate support for each of services in major PaaS environments. We have created rich sets of repositories each for technical capabilities and services used by typical enterprise applications as well as for the different technical services exposed for use by PaaS platforms along with their limitations and caveats. Using these repositories, our approach analyses the source code as well as the configuration files to recursively extract the services it requires and then tries to map them to a target PaaS platform. The approach results in a detailed report of the parts of the system that can migrate as-is, which need some changes, as well as those which can't be migrated at all due to the limitations of the chosen PaaS platform.

Performance is one of the key drivers for migrating existing systems to Cloud. While Cloud computing platforms come with a promise of scaling on demand, simple lift and shift of an existing application to Cloud would often not be the best solution. The design of a software system has a significant bearing on its performance and while migrating to Cloud, certain design patterns, can be detrimental to software performance. The area of detecting performance antipatterns automatically in context of Cloud migration and assessing their effects on performance is however unstudied. In this paper we present an approach to assess a system for known performance antipatterns, before Cloud migration. Our approach leverages static analysis and also factors in information about the prospective deployment on Cloud to evaluate whether certain antipatterns become prominent if the system is migrated to Cloud. We have found that the presence of these performance antipatterns can actually worsen the performance of parts of a software system containing them, when compared to those without these.

Platform as a Service Clouds typically lack direct support for application state management, and traditional state management techniques like clustering are not applicable as PaaS platforms offer little support for changing the underlying platform configuration. In this paper we build upon our earlier work where we proposed a session-state management architecture for Cloud called ReLoC, that uses loosely-coupled services and platform agnostic scalable messaging technology to propagate and save session states. Here, we present an actual implementation of the ReLoC onto a PaaS platform and an empirical evaluation of the original hypotheses of scalability and resilience of the proposed application architecture. We also present the challenges faced in implementing ReLoC on Heroku. The results indicate that ReLoC indeed allows applications to scale well and mitigates failures in individual application instances while maintaining state and hiding such failures from the users. The results also indicate that the performance degradation due to use of ReLoC is minimal and it is thus a promising approach for resilient user state management on PaaS Clouds.

Maintaining the state of applications and user sessions is difficult in large scale web-based software systems. This problem is particularly accentuated in the context of Cloud computing as Cloud providers, especially Platform as a Service (PaaS) vendors, do not explicitly support state management infrastructure - such as clustering. In a PaaS environment, a user has little or no access and control over the server platform and session management layer. Additionally, the platform tiers are generally loosely coupled and service-oriented. These make traditional session-state management techniques non-usable. In this work, we present ReLoC - a session-state management architecture for Cloud that uses loosely-coupled services and platform agnostic scalable messaging technology to propagate and save session states. Preliminary experiments show a very high level of tolerance to failures of the platform tiers without corresponding disruptions in user sessions. We argue that, in the context of PaaS Clouds, ReLoC architecture will be more scalable compared to traditional clustering environments.

Cloud Computing is increasingly becoming popular as many enterprise applications and data are moving into cloud platforms. However, a major barrier for cloud adoption is real and perceived lack of security. In this paper, we take a holistic view of cloud computing security - spanning across the possible issues and vulnerabilities connected with virtualization infrastructure, software platform, identity management and access control, data integrity, confidentiality and privacy, physical and process security aspects, and legal compliance in cloud. We present our findings from the points of view of a cloud service provider, cloud consumer, and third-party authorities such as Govt. We also discuss important research directions in cloud security in areas such as Trusted Computing, Information Centric Security and Privacy Preserving Models. Finally, we sketch a set of steps that can be used, at a high level, to assess security preparedness for a business application to be migrated to cloud.

Practitioners spend significant amounts of time creating high-level design from requirements. Though there exist methodologies to describe and manage requirements and design artifacts, there is not yet an automated way to faithfully translate a requirement into a high-level design. While it is extremely difficult to generate design elements from free-form natural language due to its inherent ambiguity, it is possible to significantly improve the accuracy of the design from relatively structured and constrained natural language. In this paper we propose a technique to generate high-level class diagrams from a set of requirements, using a set of requirement-specific heuristics. In this approach, we leverage work we had previously done to first process a requirement statement to classify it into a requirement type, and then break it into various constituents. Depending on the requirement type and its constituents, our heuristics then discover a functional design comprising of coarse-grained modules, their relationships and responsibilities. We express the design as a UML class diagram in IBM rational software architect (RSA) format. Our preliminary investigation shows that the resulting class diagram is rich, and can be used by practitioners as a basis for further design.

Most software reliability growth models work under the assumption that reliability of software grows due to the removal of bugs that cause failures. However, another phenomenon has often been observed—the failure rate of a software product following its release decreases with time even if no bugs are corrected. In this article we present a simple model to represent this phenomenon. We introduce the concept of initial transient failure rate of the product and assume that it decays with a factor α per unit time thereby increasing the product reliability with time. When the transient failure rate decays away, the product displays a steady state failure rate. We discuss how the parameters in this model—initial transient failure rate, decay factor, and steady state failure rate—can be determined from the failure and sales data of a product. We also describe how, using the model, we can determine the product stabilization time—a product quality metric that describes how long it takes a product to reach close to its stable failure rate. We provide many examples where this model has been applied to data from released products.

Performance engineering is an important activity for software architects and designers. Assessment and tuning of performance can help to make key changes in the system, especially if done early in its development. In this paper, we present a tool for the performance assessment and tuning for systems following the tiered architecture, which is a very commonly used architecture style. The Web-based tool allows a software designer to specify the system under design and ascertain the different performance attributes as well as the variation in performance with load. If the predicted performance is not satisfactory, the tool helps the designer with ascertaining the changes that need to be done for achieving the desired performance. Using an iterative analysis, it presents the designer with detailed steps in terms of improvements at the software and the hardware level that are necessary to improve the system performance to the desired level. We present an overview of the analysis and tuning approach, along with an example to illustrate the use of the tool

In software products, often the failure rate decreases after installation, eventually reaching a steady state. The time it takes for a product to reach its steady state reliability depends on different product parameters. In this paper we propose a new metric for software products called stabilization time which is the time taken after installation for the reliability of the product to stabilize. This metric can be used for comparing products, and can be useful for organizations and individuals using the product as well as for the product vendor. We also present an approach for determining the stabilization time of a product from its failure and sales data. We apply the approach to three real life products using their failure and sales data after release

High reliability and performance are vital for software systems handling diverse mission critical applications. Such software systems are usually component based and may possess multiple levels of fault recovery. A number of parameters, including the software architecture, behavior of individual components, underlying hardware, and the fault recovery measures, affect the behavior of such systems, and there is a need for an approach to study them. In this paper we present an integrated approach for modeling and analysis of component based systems with multiple levels of failures and fault recovery both at the software, as well as the hardware level. The approach is useful to analyze attributes such as overall reliability, performance, and machine availabilities for such systems, wherein failures may happen at the software components, the operating system, or at the hardware, and corresponding restarts, retries, reboots or repairs are used for mitigation. Our approach encompasses Markov chain, and queueing network modeling, for estimating system reliability, machine availabilities and performance. The approach is helpful for designing and building better systems and also while improving existing systems