A Study of Concurrency Bugs and Advanced Development Support for Actor-based Programs

The actor model is an attractive foundation for developing concurrent applications because actors are isolated concurrent entities that communicate through asynchronous messages and do not share state. Thereby, they avoid concurrency bugs such as data races, but are not immune to concurrency bugs in general. This study taxonomizes concurrency bugs in actor-based programs reported in literature. Furthermore, it analyzes the bugs to identify the patterns causing them as well as their observable behavior. Based on this taxonomy, we further analyze the literature and find that current approaches to static analysis and testing focus on communication deadlocks and message protocol violations. However, they do not provide solutions to identify livelocks and behavioral deadlocks. The insights obtained in this study can be used to improve debugging support for actor-based programs with new debugging techniques to identify the root cause of complex concurrency bugs.Comment: - Submitted for review - Removed section 6 "Research Roadmap for Debuggers", its content was summarized in the Future Work section - Added references for section 1, section 3, section 4.3 and section 5.1 - Updated citation

Efficiency Performance Evaluation on Multi-user Web Application Platforms in Cloud Computing

Cloud computing is a well-known paradigm nowadays because it decreases the cost to access the application, for a massive amount of data from anywhere in the world via internet. This paper takes the approach of testing the performance of web application deployment environment. The main objective of this paper was to investigate the performance of web application deployment infrastructure by growing eventually the number of users that visit the web application concurrently. The infrastructure that was used is part of the services provided by cloud computing, more specifically Platform as a Service (PaaS). This service provided a runtime environment in which we easily created, tested and deployed the web application. Tests were designed by using an open source tool. Web application subject for testing purposes was an open source pet shop application which fulfils the criteria of being a multi-user web application. Tests were created by using an open source application called Apache JMeter. One of main goals was to develop a proper test plan by considering user behaviour accessing a web application. We have developed and implemented three scenarios, started with deployment of the platform, installing dependencies and finally installing the web application used for performance testing. We have tested 2 different deployment platforms, in the first environment everything is installed in one machine and in second environment we separate application server from the database server. We have concluded in results where processes like register, login and checkout consumes much more resources of the server. In the future we will try to understand where machine learning stands in this part of web application development and how it can affect deployment infrastructure

On verifying the use of a pattern language in model driven design

This thesis addresses the problem of verifying the application of a Pattern Language in a design that is built based upon the patterns of the language in a Model-Driven approach. Exploiting the ideas of compilers, we propose a process named Pattern Language Verifier (PLV). We argue that building a PLV for a given Pattern Language, requires the Structural, Syntactic, and Semantic rules of the language to be precisely defined. We present three formalisms for defining these three groups of rules. PLV is a profile-driven process and assumes that a UML Profile is already defined for the underlying Pattern Language. PLV consists of four phases: Pattern Structural Verifier (PSV), Pattern Language Syntactic Verifier (PTV), Pattern Language Semantic Verifier (PMV), and Pattern Language Advisor (PLA). PSV verifies the structure of every single pattern used in the design model. PTV verifies the relationships between the detected patterns. PMV verifies the semantic aspects of the patterns. PLA reports the problems to the designer and guides him/her in fixing the errors. For the case study, a group of enterprise architectural patterns is selected as the Pattern Language. The Structural, Syntactic, and Semantic rules of the language are defined using the proposed formalism, and a UML Profile is defined for the language. A PLV is designed and implemented as an integration into an open source modeling tool. The tool is then utilized in designing a sample web application: Online Student Registration System. The usefulness of the tool is represented by walkthrough scenarios that show finding the mistakes in the model and helping the designer repair the detected problem

Automatic Software Repair: a Bibliography

This article presents a survey on automatic software repair. Automatic software repair consists of automatically finding a solution to software bugs without human intervention. This article considers all kinds of repairs. First, it discusses behavioral repair where test suites, contracts, models, and crashing inputs are taken as oracle. Second, it discusses state repair, also known as runtime repair or runtime recovery, with techniques such as checkpoint and restart, reconfiguration, and invariant restoration. The uniqueness of this article is that it spans the research communities that contribute to this body of knowledge: software engineering, dependability, operating systems, programming languages, and security. It provides a novel and structured overview of the diversity of bug oracles and repair operators used in the literature

A Review on Web Application Testing and its Current Research Directions

Testing is an important part of every software development process on which companies devote considerable time and effort. The burgeoning web applications and their proliferating economic significance in the society made the area of web application testing an area of acute importance. The web applications generally tend to take faster and quicker release cycles making their testing very challenging. The main issues in testing are cost efficiency and bug detection efficiency. Coverage-based   testing is the process of ensuring exercise of specific program elements. Coverage measurement helps determine the “thoroughness” of testing achieved. An avalanche of tools, techniques, frameworks came into existence to ascertain the quality of web applications.  A comparative study of some of the prominent tools, techniques and models for web application testing is presented. This work highlights the current research directions of some of the web application testing techniques

Systems, methods and apparatus for generation and verification of policies in autonomic computing systems

Described herein is a method that produces fully (mathematically) tractable development of policies for autonomic systems from requirements through to code generation. This method is illustrated through an example showing how user formulated policies can be translated into a formal mode which can then be converted to code. The requirements-based programming method described provides faster, higher quality development and maintenance of autonomic systems based on user formulation of policies.Further, the systems, methods and apparatus described herein provide a way of analyzing policies for autonomic systems and facilities the generation of provably correct implementations automatically, which in turn provides reduced development time, reduced testing requirements, guarantees of correctness of the implementation with respect to the policies specified at the outset, and provides a higher degree of confidence that the policies are both complete and reasonable. The ability to specify the policy for the management of a system and then automatically generate an equivalent implementation greatly improves the quality of software, the survivability of future missions, in particular when the system will operate untended in very remote environments, and greatly reduces development lead times and costs

Towards Advanced Debugging Support for Actor Languages: Studying Concurrency Bugs in Actor-based Programs

With the ubiquity of multicore hardware, concurrent and parallel programming has become a fundamental part of software development. If writing concurrent programs is hard, debugging them is even harder. The actor model is attractive for developing concurrent applications because actors are isolated concurrent entities that communicates through asynchronous message sending and do not share state, thus they avoid common concurrency bugs such as race conditions. However, they are not immune to bugs. This paper presents initial work on a taxonomy of concurrent bugs for actor based applications. Based on this study, we propose debugging tooling to assist the development process of actor-based applications