The choice of pattern of data access from database tables is critical for a microservice to maximize benefits of distributed architecture. Traditionally, microservices have been designed using shared table access pattern commonly referred to as CRUD pattern. More recently, there has been a growing interest in applying other patterns like CQRS. In this work, we propose a system that recommends the most suitable pattern for a microservice as per the separation in read and write operations in the transactions performed by the service.

In this paper, we propose a novel approach for monolith decomposition, that maps the implementation structure of a monolith application to a functional structure that in turn can be mapped to business functionality. First, we infer the classes in the monolith application that are distinctively representative of the business functionality in the application domain. This is done using formal concept analysis on statically determined code flow structures in a completely automated manner. Then, we apply a clustering technique, guided by the inferred representatives, on the classes belonging to the monolith to group them into different types of partitions, mainly: 1) functional groups representing microservice candidates, 2) a utility class group, and 3) a group of classes that require significant refactoring to enable a clean microservice architecture. This results in microservice candidates that are naturally aligned with the different business functions exposed by the application. A detailed evaluation on four publicly available applications show that our approach is able to determine better quality microservice candidates when compared to other existing state of the art techniques. We also conclusively show that clustering quality metrics like modularity are not reliable indicators of microservice candidate goodness.

Automatic business process discovery from textual process documentation is highly desirable to reduce the time and cost of Business Process Management (BPM) implementation in organizations. However, existing automatic process discovery approaches mainly focus on identifying activities out of the documentations. Deriving the hierarchical structural relationships between activities, which is important in the whole process discovery scope, requires great human labeling effort and is still a challenge. Facing this challenge, we propose to retrieve the latent hierarchical structure present in the textual process documentation by building a neural network without any extra human-labeled knowledge. The proposed neural network leverages a novel recurrent architecture, Ordered Neurons LSTM (ON-LSTM), with a process-level language model objective. On the base of this, we provide an automatic business process service (A-BPS) which could support the goal of automatically discovering business processes out of the uploaded documentation and generate Business Process Model and Notation (BPMN) scripts to represent the discovered process model through a service ecosystem. Experimental results show that 58.76% of the hierarchical structures could be correctly retrieved. A-BPS could generate 32% of the whole BPMN process model with average execution time 5-8 minutes. The time benefit of A-BPS is up to 40% reduction.

Ticket assignment/dispatch is a crucial part of service delivery business with lot of scope for automation and optimization. In this paper, we present an end-to-end automated helpdesk email ticket assignment system, which is also offered as a service. The objective of the system is to determine the nature of the problem mentioned in an incoming email ticket and then automatically dispatch it to an appropriate resolver group (or team) for resolution.The proposed system uses an ensemble classifier augmented with a configurable rule engine. While design of a classifier that is accurate is one of the main challenges, we also need to address the need of designing a system that is robust and adaptive to changing business needs. We discuss some of the main design challenges associated with email ticket assignment automation and how we solve them. The design decisions for our system are driven by high accuracy, coverage, business continuity, scalability and optimal usage of computational resources.Our system has been deployed in production of three major service providers and currently assigning over 90,000 emails per month, on an average, with an accuracy close to 90% and covering at least 90% of email tickets. This translates to achieving human-level accuracy and results in a net saving of more than 50000 man-hours of effort per annum. Till date, our deployed system has already served more than 700,000 tickets in production.

Search results in technical forums are typically keyword based. The relevance of a link is usually gauged by closest content match. However, it has been shown in literature that users' click behavior is an integral part of deciding the relevance of a search result. Moreover, it is not just the number of clicks that matter, but time spent on a clicked link, order in which the links were clicked etc. also play an important role in the relevance decision. In this paper, we have developed a service that analyzes the click logs of searches performed in the technical forums and learns the new relevance scores for the search results with respect to a query. The computation model for relevance is an optimization problem, the constraints for which have been designed based on real user behavior study. We ingested StackOverflow data for few domains and designed a QA style search to carry out the study. We have developed heuristics to solve the optimization problem and have validated the relevance model using user behavior simulations. The relevance model is shown to yield efficient, robust and effective rank order using DCG (discounted cumulative gains) and stability metrics.

Workforce management is a growing concern in people intensive service organizations like IT service delivery. The knowledge workers tend to get de-motivated due to the mundane nature of maintenance tasks assigned to them. To tackle this problem, many organizations are willing to experiment with novel methods of work allocation that provide certain amount of autonomy to the knowledge workers by enabling them to choose what they want to work on. In this paper, we propose a method of work allocation that provides opportunities to employees to choose their work without the organization having to compromise on the regular business tasks. The idea is to use crowdsourcing concepts for the tasks that will enable employees to showcase their skills and talent. We have modeled crowdsourced cum managerial assignments , which we call Hybridsourcing, as an auction mechanism and use game theoretic analysis for studying the competition among players and the tradeoffs for the organization. As part of the auction mechanism for carrying out Hybridsourcing, two games have been formulated based on: 1) players have common knowledge about the operation costs and 2) operation costs are a private information. We show the existence and uniqueness of a Nash equilibrium (NE) in both the cases and provide an algorithm bounded by polynomial complexity in order to compute the NE. The outcome of the mechanism is defined by the unique NE. Furthermore, we study the pros and cons of our mechanism vis-a-vis the popular auction based mechanisms like VCG and few others. We also show that the mechanism allows for flexible autonomy making it very practical.

In an IT service delivery environment, the speedy dispatch of a ticket to the correct resolution group is the crucial first step in the problem resolution process. The size and complexity of such environments make the dispatch decision challenging, and incorrect routing by a human dispatcher can lead to significant delays that degrade customer satisfaction, and also have adverse financial implications for both the customer and the IT vendor. In this paper, we present SmartDispatch, a learning-based tool that seeks to automate the process of ticket dispatch while maintaining high accuracy levels. SmartDispatch comes with two classification approaches - the well-known SVM method, and a discriminative term-based approach that we designed to address some of the issues in SVM classification that were empirically observed. Using a combination of these approaches, SmartDispatch is able to automate the dispatch of a ticket to the correct resolution group for a large share of the tickets, while for the rest, it is able to suggest a short list of 3-5 groups that contain the correct resolution group with a high probability. Empirical evaluation of SmartDispatch on data from 3 large service engagement projects in IBM demonstrate the efficacy and practical utility of the approach.

General barrier synchronization is widely used in multiprocessor programming with the introduction of multicore processors. In this paper, we describe a solution for the barrier synchronization of processes (that are not bounded or known a priori) that can dynamically join or drop out of barrier synchronization. A new process can join only in the beginning of each phase along with all the other members; that is, at the beginning of a phase everyone is aware of the other members involved in synchronization. We design a protocol using the above policy that guarantees starvation freedom, i.e., any process wanting to join phase synchronization shall do so within at most two phases.

The performance of parallel programs can be largely affected by the latency of remote memory references. The notion of affinity has been used extensively for scheduling programmer defined threads to reduce remote communication costs. The most popular approach has been to schedule the thread as close to the data as possible. Most of the existing techniques expect the programmer to annotate affinity related information used by the scheduler. In this paper, we propose a framework that qualifies and quantifies various possible affinities playing a role in memory access latency in a system comprising of threads, processor nodes and data objects. We propose a technique based on cost functions to arrive at affinity information that can be used for reducing latencies. The affinity information thus obtained can be used in a number of ways such as: (1) transform the user program automatically (i.e., oblivious to the programmer); (2) highlight the user code in the integrated development toolkit used by the programmer; and (3) provide annotations that can be understood by the scheduler in making dynamic decisions of allocating objects and assigning threads to nodes. We support our framework and algorithm with the case studies/experiments done so far.

X10 is a modern object-oriented programming language designed for high performance, high productivity programming of parallel and multi-core computer systems. Compared to the lower-level thread-based concurrency model in the JavaTM language, X10 has higher-level concurrency constructs such as async, atomic and finish built into the language to simplify creation, analysis and optimization of parallel programs. In this paper, we introduce a new algorithm for May-Happen-in-Parallel (MHP) analysis of X10 programs. The analysis algorithm is based on simple path traversals in the Program Structure Tree, and does not rely on pointer alias analysis of thread objects as in MHP analysis for Java programs. We introduce a more precise definition of the MHP relation than in past work by adding condition vectors that identify execution instances for which the MHP relation holds, instead of just returning a single true/false value for all pairs of executing instances. Further, MHP analysis is refined in our approach by using the observation that two statement instances which occur in atomic sections that execute at the same X10 place must have MHP = false. We expect that our MHP analysis algorithm will be applicable to any language that adopts the core concepts of places, async, finish, and atomic sections from the X10 programming model. We also believe that this approach offers the best of two worlds to programmers and parallel programming tools ---higher-level abstractions of concurrency coupled with simple and efficient analysis algorithms.

In this paper,we address the problem of guaranteeing the absence of physical deadlock in the execution of a parallel program using the async, finish, atomic, and place constructs from the X10 language. First, we extend previous work-stealing memory bound results for fully strict multi-threaded computations to terminally strict multithreaded computations in which one activity may wait for completion of a descendant activity (as in X10's async and finish constructs), not just an immediate child (as in Cilk 's spawn and sync constructs). This result establishes physical dead-lock freedom for SMP deployments.Second,we introduce a new class of X10 deployments for clusters, which builds on an underlying Active Message network and the new concept of Doppelgänger mode execution of X10 activities. Third, we use this new class of deployments to establish physical deadlock freedom for deployments on clusters of uniprocessors.