Scenario-based software architecture for designing connectors framework in distributed system

Software connectors is one of key word in enterprise information system. In recent years, software developers have facing more challenges of connectors which are used to connect distributed components. Design of connectors in an existing system encounters many issues such as choosing the connectors based on scenario quality, matching these connectors with design pattern, and implementing them. Especially, we concentrate on identifying the attributes that interest an observer, identifying the functions where these connectors could be applied, and keeping all applications clean after adding new connectors. Each problem is described by a scenario to design architecture, especially to design a connector based on architecture attributes. In this paper, we develop a software framework to design connectors between components and solution of these issues. A case study is done to maintain high level of independency between components and to illustrate this independency. This case study uses Aspect-Oriented Programming (AOP) and AspectJ, Design Pattern to and Program Slicing to solve main problems of design of connectors. A conclusion is given at the end of this paper

A proposed java forward slicing approach

Many organization, programmers, and researchers need to debug, test and make maintenance for a segment of their source code to improve their system. Program slicing is one of the best techniques to do so. There are many slicing techniques available to solve such problems such as static slicing, dynamic slicing, and amorphous slicing. In our paper, we decided to develop a tool that supports many slicing techniques. Our proposed tool provides new flexible ways to process simple segments of Java code, and it generates needed slicing according to the user needs, our tool will provide the user with direct and indirect dependencies for each variable in the code segments. This tool can work under various operating systems and does not need particular environments. Thus, our tool is helpful in many aspects such as debugging, testing, education, and many other elements

Reducing Complexity of Java Source Codes in Structural Testing by Using Program Slicing

Structural testing is one of the techniques of software testing. It tests only the structure of the source code while comparing expected results and actual results. Generally, structural testing takes a long time to perform its task and not possible. Sometimes, only a small portion of the program is relevant. This can be done by program slicing. Program Slicing is to decompose the program into smaller units that depends on different types of dependencies between the program statements. The different types of program slicing are forward slicing, backward slicing, complete slicing, dynamic and static slicing, etc. Moreover, there is Tree Slicing which is also a key technique to slice and merge different Symbolic Execution (SE) sub-trees under some specific conditions.  In this paper, we combine Tree Slicing technique and Indus Kaveri where Indus is a robust framework for analyzing and slicing concurrent Java programs, and Kaveri is a feature-rich Eclipse-based GUI front end for Indus slicing. Then we present the experimental results in order to reduce the complexity of the java source code

Extracting and verifying coordination models from source code

Current software development relies increasingly on non-trivial coordination logic for combining autonomous services often running on different platforms. As a rule, however, intypical non-trivial software systems, such a coordination layer is strongly weaved within the application at source code level. Therefore, its precise identification becomes a major methodological (and technical) problem which cannot be overestimated along any program understanding or refactoring process. Open access to source code, as granted in OSS certification, provides an opportunity for the development of methods and technologies to extract, from source code, the relevant coordination information. This paper is a step in this direction, combining a number of program analysis techniques to automatically recover coordination information from legacy code. Such information is then expressed as a model in Orc, a general purpose orchestration language

Fabrication, structure and properties of epoxy/metal nanocomposites

Gd2O3 nanoparticles surface-modified with IPDI were compounded with epoxy. IPDI provided an anchor into the porous Gd2O3 surface and a bridge into the matrix, thus creating strong bonds between matrix and Gd2O3. 1.7 vol.-% Gd2O3 increased the Young’s modulus of epoxy by 16–19%; the surface-modified Gd2O3 nanoparticles improved the critical strain energy release rate by 64.3% as compared to 26.4% produced by the unmodified nanoparticles. The X-ray shielding efficiency of neat epoxy was enhanced by 300–360%, independent of the interface modification. Interface debonding consumes energy and leads to crack pinning and matrix shear banding; most fracture energy is consumed by matrix shear banding as shown by the large number of ridges on the fracture surface

Slicing for Java Program: A Preliminary Study

Program slicing is a technique that proposed to help in understanding the program code. After several decades, the technique has been derived into several other techniques and proposed to be applied in many fields such as debugging, program comprehension, software measurement, testing and maintenance. The application of program slicing sometimes specifies for certain programming language such as C and Java. This paper will discuss existing program slicing techniques that were proposed focusing on the Java programming language

A perspective on architectural re-engineering

Continuous evolution towards very large, heterogeneous, highly dynamic computing systems entails the need for sound and flexible approaches to deal with system modification and re-engineering. The approach proposed in this paper combines an analysis stage, to identify concrete patterns of interaction in legacy code, with an iterative re-engineering process at a higher level of abstraction. Both stages are supported by the tools CoordPat and Archery, respectively. Bi-directional model transformations connecting code level and design level architectural models are defined. The approach is demonstrated in a (fragment of a) case study.This work is funded by the ERDF through the Programme COMPETE and by FCT, the Portuguese Foundation for Science and Technology, under contract FCOMP-01-0124-FEDER-028923

Finding Patterns in Static Analysis Alerts: Improving Actionable Alert Ranking

Static analysis (SA) tools that find bugs by inferring programmer beliefs (e.g., FindBugs) are commonplace in today’s software industry. While they find a large number of actual defects, they are often plagued by high rates of alerts that a developer would not act on (unactionable alerts) because they are incorrect, do not significantly affect program execution, etc. High rates of unactionable alerts decrease the utility of static analysis tools in practice. We present a method for differentiating actionable and unactionable alerts by finding alerts with similar code patterns. To do so, we create a feature vector based on code characteristics at the site of each SA alert. With these feature vectors, we use machine learning techniques to build an actionable alert prediction model that is able to classify new SA alerts. We evaluate our technique on three subject programs using the FindBugs static analysis tool and the FaultBench benchmark methodology. For a developer inspecting the top 5% of all alerts for three sample projects, our approach is able to identify 57 of 211 actionable alerts, which is 38 more than the FindBugs priority measure. Combined with previous actionable alert identification techniques, our method finds 75 actionable alerts in the top 5%, which is four more actionable alerts (a 6% improvement) than previous actionable alert identification techniques