Source Code Of System Research Articles

RETUSS: Ensuring Traceability System between Class Diagram in UML and Java Source Code in Real Time

Ensuring of the traceability of deliverables is one of effective methods to secure the quality of software. It can verify that the requirements are reflected in the programs. But it has two problems: taking much labor and time, and causing mistakes by human handling. This paper has implemented RETUSS (Real-time Ensure Traceability between UML and Source-code System) in order to solve the above two problems. RETUSS can ensure traceability between Class diagram in UML and Java source code in real time.

Model of vulnerability accumulation in source code of JAVA applications and binary system of estimation of the quality of the source code based on it

The article is devoted to the problem of evaluation of the quality of the source code of Java applications and libraries. The article shows that the investigated set of 60,956 GitHub repositories does not fit the normal distribution law by the number of lines of source code. The developed model of accumulation of vulnerabilities in the source code from the number of lines of source code allowed creating a binary system for assessing the quality of source code for Java-based applications and libraries. Figs.: 3. Tabl.: 1. Refs.: 11 titles.Keywords: code quality; vulnerability; vulnerability model; Java; quality assessment system.

Optimizing distributed data stream processing by tracing

Heterogeneous mobile, sensor, IoT, smart environment, and social networking applications have recently started to produce unbounded, fast, and massive-scale streams of data that have to be processed “on the fly”. Systems that process such data have to be enhanced with detection for operational exceptions and with triggers for both automated and manual operator actions. In this paper, we illustrate how tracing in distributed data processing systems can be applied to detecting changes in data and operational environment to maintain the efficiency of heterogeneous data stream processing systems under potentially changing data quality and distribution. By the tracing of individual input records, we can (1) identify outliers in a web crawling and document processing system and use the insights to define URL filtering rules; (2) identify heavy keys, such as NULL, that should be filtered before processing; (3) give hints to improve the key-based partitioning mechanisms; and (4) measure the limits of overpartitioning if heavy thread-unsafe libraries are imported.By using Apache Spark as illustration, we show how various data stream processing efficiency issues can be mitigated or optimized by our distributed tracing engine. We describe and qualitatively compare two different designs, one based on reporting to a distributed database and another based on trace piggybacking. Our prototype implementation consists of wrappers suitable for JVM environments in general, with minimal impact on the source code of the core system. Our tracing framework is the first to solve tracing in multiple systems across boundaries and to provide detailed performance measurements suitable for automated optimization, not just debugging.

Efficiently detecting structural design pattern instances based on ordered sequences

In software engineering, a design pattern is a general reusable solution to a commonly occurring problem within a given context in software design. Design patterns reveal much about the high-level abstract designs of software systems. Accurately discovering design pattern instances in software systems helps developers and maintainers to understand the original design and implementation, and to facilitate the re-development, upgrade and maintenance. In recent years, numerous approaches have been proposed to discover design pattern instances from system source code. Among them, many transform the source code and design patterns into graphs, and then discover the isomorphic sub-graphs of design patterns from the graph of software system. However, as testing sub-graph isomorphism is an NP-complete problem, those approaches usually fail to achieve satisfactory efficiency. On the other hand, a real time response of detecting pattern instance is in fact essential. To address this problem, we propose a novel efficient approach to detect structural design pattern instances based on directed sub-graph isomorphism. In particular, we put forward a well-designed search order, or Ordered Sequences, by which the candidate pattern instances can be rapidly detected. Because the Ordered Sequences guide the search process in such an order that the most representative classes are discovered first, a large number of irrelevant classes can be filtered out at early stage, which greatly reduces the search space. We employ our approach on four well-known open-source systems. The results of extensive experiments for discovering instances of all GoF structural design patterns verify that our approach obtains 100% recall and the high precision. In addition, the experiment conducted on two other large scale open-source projects indicates that our approach runs significantly faster than the compared approach.

An Integrated Model for Information Retrieval Based Change Impact Analysis

The paper presents an approach to combine multiple existing information retrieval (IR) techniques to support change impact analysis, which seeks to identify the possible outcomes of a change or determine the necessary modifications for affecting a desired change. The approach integrates a bag-of-words based IR technique, where each class or method is abstracted as a set of words, and a neural network based IR technique to derive conceptual couplings from the source code of a software system. We report rigorous empirical assessments of the changes of three open source systems: jEdit, muCommander, and JabRef. The impact sets obtained are evaluated at the method level of granularity, and the results show that our integrated approach provides statistically significant improvements in accuracy across several cut points relative to the accuracies provided by the individual methods employed independently. Improvements in F-score values of up to 7.3%, 10.9%, and 17.3% are obtained over a baseline technique for jEdit, muCommander, and JabRef, respectively.

INFERRING UML STATE MACHINE FROM JAVA CODE

Ponte Academic JournalJan 2018, Volume 74, Issue 1 INFERRING UML STATE MACHINE FROM JAVA CODEAuthor(s): M.H. Aabidi ,E. Bouziane, C. Baidada, A. JakimiJ. Ponte - Jan 2018 - Volume 74 - Issue 1 doi: 10.21506/j.ponte.2018.1.1 Abstract:Software documentation is essential to understand the structure and behavior of an application. Soft-ware development starts with sound documentation and design but during the course of time, design document or other software artifacts are neither updated or nor well maintained. It is very essential to understand the existing system to maintain and to evolve it with new requirements. Reverse engineer-ing extracts and retrieves the missing software documentation in the form of abstract UML model from existing source code. This enables developers to gain better understanding of the existing source code of system. Reverse engineering of behavioral models consists in extracting high-level models that help to understand the behavior of existing software systems. In this paper we present a new approach on extracting UML2 state machine diagram from Object-Oriented Java source code using Nested choice patterns, motivated by the popularity of state machine models in software systems. Download full text:Check if you have access through your login credentials or your institution Username Password

Experience Report: Towards Extending an OSEK-Compliant RTOS with Mixed Criticality Support

Background: With an increase of the number of features in a vehicle, the computational requirements also increase, and vehicles may contain up to 100 Electronic Control Units (ECUs) to accommodate these requirements. For cost-e ectiveness reasons, amongst others, it is considered desirable to limit the growth of, or preferably reduce, the number of ECUs. To that end, mixed criticality is a promising approach that received a lot of attention in the literature, primarily from a theoretical perspective. Aim: In this paper, we address mixed criticality from a practical perspective. Our prime goal is to extend an OSEK-compliant real-time operating system (RTOS) with mixed criticality support, enabling such support in the automotive domain. In addition, we aim at a system (i) supporting more than two criticality levels; (ii) with minimal overhead upon an increase of the so-called criticality level indicator of the system; (iii) requiring no changes to an underlying operating system; and (iv) featuring further extensions, such as hierarchical scheduling and multi-core. Method: We used the so-called adaptive mixed criticality (AMC) scheme as a starting point for mixed criticality. We extended that scheme from two to more than two criticality levels (satisfying (i)) and complemented it with specified behavior for criticality level changes. We baptized our extended scheme AMC*. Rather than selecting a specific OSEK-compliant RTOS, we selected ExSched, an operating system independent external CPU scheduler framework for real-time systems, which requires no modifications to the original operating system source code (satisfying (iii)) and features further extensions (satisfying (iv)). Results: Although we managed to build a functional prototype of our system, our experience with ExSched made us decide to rebuild the system with a specific OSEK-compliant RTOS, being µC/OS-II. We also briefly report upon our experience with AMC* and suggest directions for improvements. Conclusions: Compared to extending ExSched with AMC*, extending µC/OS-II turned out to be straightforward. Although we now have a basic system operational and available for experimentation, enhancements of the AMC*-scheme are considered desirable before exploitation in a vehicle.

On a Class of Multi-Source Distributed Storage With Exact Repair

In future communication networks, say 5G networks and Internet of Things, users may need to obtain messages from multiple available sources in a distributed manner, which requires distributed storage in the network. One essential issue in distributed storage is how to repair a failed storage node. In conventional distributed storage model with exact repair, source files are stored in many nodes in a distributed manner and the contents of a failed node are exactly recovered by the surviving nodes. Further, all files can be reconstructed when a decoder has access to a certain number of storage nodes. So, the underlying reconstruction network is equivalent to a single-source multicast problem. This paper considers a variant of the exact repair problem, where the underlying reconstruction network is the independent distributed source coding system, a type of multi-source multicast problem. As the first non-trivial case with two sources and three encoders, the storage-repair tradeoff regions are proved for all the 33 non-isomorphic instances, and it is shown that binary codes are optimal.

Reliability-Oriented Decoding Strategy for LDPC Codes-Based D-JSCC System

In this letter, a reliability oriented decoding strategy (RODS) for low density parity check codes-based distributed joint source and channel coding system is proposed. During each local decoding iteration, the reliability of each variable node is evaluated based on the sign of received log-likelihood ratios (LLRs) and its oscillation situation. Then, by employing reliability-oriented updating operation, the negative influence of those inaccurate messages is suppressed. Moreover, extra operations are performed on a group of most unreliable source nodes so that more accurate posteriori LLRs can be obtained. During global iteration, offset operation is performed to reduce error propagation. The simulation results illustrate that the proposed RODS outperforms other decoding algorithms at the aspects of error correction performance and convergence speed, especially when the correlation between distributed sources is low.

Identifying Classes in Legacy JavaScript Code

JavaScript is the most popular programming language for the Web. Although the language is prototype-based, developers can emulate class-based abstractions in JavaScript to master the increasing complexity of their applications. Identifying classes in legacy JavaScript code can support these developers at least in the following activities: (i) program comprehension; (ii) migration to the new JavaScript syntax that supports classes; and (iii) implementation of supporting tools, including IDEs with class-based views and reverse engineering tools. In this paper, we propose a strategy to detect class-based abstractions in the source code of legacy JavaScript systems. We report on a large and in-depth study to understand how class emulation is employed, using a dataset of 918 JavaScript applications available on GitHub. We found that almost 70% of the JavaScript systems we study make some usage of classes. We also performed a field study with the main developers of 60 popular JavaScript systems in order to validate our findings. The overall results range from 97% to 100% for precision, from 70% to 89% for recall, and from 82% to 94% for F-score.

Case study on which relations to use for clustering-based software architecture recovery

Clustering-based software architecture recovery is an area that has received significant attention in the software engineering community over the years. Its key concept is the compilation and clustering of a system-wide graph that consists of source code entities as nodes, and source code relations as edges. However, the related research has mostly focused on investigating different clustering methods and techniques, and consequently there is limited work on addressing the question of what is a minimal set of relations that can be easily extracted from the system's source code, and yet can be accurately used for extracting its architecture. In this paper, we report on results obtained from an architecture recovery case study we have conducted, by considering all possible combinations which can be generated from thirteen commonly used source code relations. We have examined the similarity of the extracted architectures obtained by using each different relation combination for different systems, against the corresponding architecture which is obtained by applying all thirteen relations and whch we consider as the ground truth architecture. For this purpose, we have also examined whether the use of all these thirteen relations is indeed adequate to yield a ground truth architecture, by applying this architecture extraction process on five large sofware systems for which their ground truth architecture has been independently established. The overall results of our study indicate that there is small set of relations for procedural systems, and another similar set for object oriented systems, that can be easily extracted from the source code and yet used to yield an architecture that is close to the ground truth architecture.

Source Code Verification for Embedded Systems using Prolog

System relevant embedded software needs to be reliable and, therefore, well tested, especially for aerospace systems. A common technique to verify programs is the analysis of their abstract syntax tree (AST). Tree structures can be elegantly analyzed with the logic programming language Prolog. Moreover, Prolog offers further advantages for a thorough analysis: On the one hand, it natively provides versatile options to efficiently process tree or graph data structures. On the other hand, Prolog's non-determinism and backtracking eases tests of different variations of the program flow without big effort. A rule-based approach with Prolog allows to characterize the verification goals in a concise and declarative way. In this paper, we describe our approach to verify the source code of a flash file system with the help of Prolog. The flash file system is written in C++ and has been developed particularly for the use in satellites. We transform a given abstract syntax tree of C++ source code into Prolog facts and derive the call graph and the execution sequence (tree), which then are further tested against verification goals. The different program flow branching due to control structures is derived by backtracking as subtrees of the full execution sequence. Finally, these subtrees are verified in Prolog. We illustrate our approach with a case study, where we search for incorrect applications of semaphores in embedded software using the real-time operating system RODOS. We rely on computation tree logic (CTL) and have designed an embedded domain specific language (DSL) in Prolog to express the verification goals.

Examining studies on learning management systems in SSCI database: A content analysis study

Distance education systems have become more prevalent over time and their use continue to increase. Learning Management Systems (LMS) is the main component for distance education to be carried out effectively and distantly. In this stuy, it is aimed to examine current studies on LMS published between 2010 and 2014 and provide an instructive source for researchers. The obtained data were analyzed and interpreted based on certain criteria. According to the results, LMS studies are mostly published in Computer & Science Journal, however there is a decline in the number of studies in 2014. Results also showed that researchers mostly conducted studies with university students and they examined the systems either developed by themselves or by an institution. It was revealed that Moodle is mostly used as open source code systems and WebCT (Blackboard) is mostly used as commercial. It can be indicated that seeking for new LMS by researchers would change based on the requirements and technological advances in the further research.

Detecting Blacklisted IP Access from Android Phone

Objectives: To develop a method to detect access of blacklisted IP from Android. Methods/Statistical Analysis: Android Operating System source code under AOSP was modified and customized to achieve objective of the work. Work was tested on various simulators with variety of black listed and whitel listed IP to confirm outcome. Findings: A well-defined method was derived and verified based on the results of tests carried out during the work. Outcome of the work is an implementation on Android operating system, which customizes the way device connects to an IP through internet. The customization done on operating system helps in identifying interaction of any black listed IP to or from an android device. A supporting python script is also written to automate steps related to interception and interpretation. As being open source, the solution is also extendable to accommodate more features in the same domain. Application / Improvements: The method developed during this research can be used in behavioral analysis of android malware.

A Perspective View of different Techniques Used in Different Phases of Load Testing

Background/Objectives: To determine the quality and system characteristics, load testing has paramount importance in addition to the traditional functional testing. This study will be useful for the researchers to detect performance problems under load. Methods/Statistical Analysis: This comprehensive study is focussed on analysing different techniques for designing the load using workload intensity and workload mix in operational profiles as well as use of system models techniques and source code analysis techniques. We compare and contrast various approaches applied in load execution phase and load analysis phase. Findings: To deal with the load related problems and for recording system behaviour, realistic load test cases are designed to see functionality. Load execution testing can be done by human beings, load testing tools and also there is a use of special platforms. After completion of load test, performance analyst use tools to perform comparison against a predefined threshold values. Applications/Improvements: Although there are many existing techniques which shows correlation between performance metrics and anomalies but in practice, valid performance techniques are often limited. So, there is a need to put attention on these issues as a future work.

A Simplified Joint Source and Channel Coding System for Data Transmission over Fading Channel

The major challenge with multimedia communication lies in the demand for higher data rates with better quality of service and lower latency over the wireless channel. Multimedia content is usually source encoded with variable length codes (VLCs) for optimizing bandwidth utilization. VLCs, even though uniquely decodable, suffer from the problem of error propagation. A single bit error can cause an entire block of data to be decoded wrongly, because the ending of a codeword and the beginning of the next can no longer be determined correctly. Several joint source-channel coding (JSCC) techniques are studied in literature to have efficient source coding with resilience to channel errors, but such methods pose a prohibitively high computational complexity. A variant of JSCC for efficient transmission of information is presented in this paper. The information text is encoded by reversible VLC (RVLC) and corresponding to it, a header sequence is generated. Since the headers are critical in decoding a block, they are channel coded with convolution code to protect from errors. Orthogonal frequency division multiplexing is used to provide high data rate communication and robustness to multipath fading. The performance of the system is analysed over Rayleigh fading channel in terms letter error rate (LER) and computational complexity. The proposed method is seen to provide a good LER performance at moderate to high signal to noise ratio, along with minimal computational complexity, when compared with the contemporary JSCC based schemes. Theoretical performance bounds for the error rate of the proposed system are also derived.

A Novel Design and Modeling of UEP-Based Compressed Video Broadcasting With Multilevel Coded Modulation

A novel coded modulation system design that maximizes the average quality of multimedia data, received by a given set of target users, is proposed for compressed video broadcasting based on unequal error protection. An integrated source and channel coding system with graceful degradation is introduced, where the multilevel coded modulation (MLC) with capacity-approaching codes is combined with an existing source compression technique. By assigning critical information that is required for decoding compressed data to the levels of MLC with higher reliability, we demonstrate that graceful degradation can be naturally incorporated into practical video broadcasting systems. Furthermore, a new measure of achievable average receiver quality, i.e., the quality of the received videos averaged over the users located within the coverage area of a given broadcasting service, is introduced. Based on the proposed measure, an optimal rate allocation algorithm for MLC, utilizing the code rate design based on channel capacity rule, is developed. In the case of MPEG-4 video coding, our numerical results reveal that a well-designed MLC system can achieve higher average quality experienced by target users than the conventional coded modulation as well as hierarchical modulation systems for a given coverage area.

Evaluation and design of function for tracing diffusion of classified information for file operations with KVM

Cases of classified information leakage have become increasingly common. To address this problem, we have proposed a function for tracing the diffusion of classified information within an operating system. However, this function suffers from the following two problems: first, in order to introduce the function, the operating system's source code must be modified. Second, there is a risk that the function will be disabled when the operating system is attacked. Thus, we have designed a function for tracing the diffusion of classified information in a guest operating system by using a virtual machine monitor. By using a virtual machine monitor, we can introduce the proposed function in various environments without modifying the operating system's source code. In addition, attacks aimed at the proposed function are made more difficult, because the virtual machine monitor is isolated from the operating system. In this paper, we describe the implementation of the proposed function for file operations and child process creation in the guest operating system with a kernel-based virtual machine. Further, we demonstrate the traceability of diffusing classified information by file operations and child process creation. We also report the logical lines of code required to introduce the proposed function and performance overheads.

A comparative study on the intensity and harmfulness of late propagation in near-miss code clones

Exact or nearly similar code fragments in a software system's source code are referred to as code clones. It is often the case that updates (i.e., changes) to a code clone will need to be propagated to its related code clones to preserve their similarity and to maintain source code consistency. When there is a delay in propagating the changes (possibly because the developer is unaware of the related cloned code), the system might behave incorrectly. A delay in propagating a change is referred to as `late propagation,' and a number of studies have investigated this phenomenon. However, these studies did not investigate the intensity of late propagation nor how late propagation differs by clone type. In this research, we investigate late propagation separately for each of the three clone types (Type 1, Type 2, and Type 3). According to our experimental results on thousands of revisions of eight diverse subject systems written in two programming languages, late propagation occurs more frequently in Type 3 clones compared with the other two clone types. More importantly, there is a higher probability that Type 3 clones will experience buggy late propagations compared with the other two clone types. Also, we discovered that block clones are more involved in late propagation than method clones. Refactoring and tracking of Similarity Preserving Change Pattern (SPCP) clones (i.e., the clone fragments that evolve following a SPCP) can help us minimize the occurrences of late propagation in clones.

Adaptive Segmented Block based Clone Detection and Refactoring using Divide and Conquer Method

The clone detection and refactoring methods are commonly utilized for the defragmentation of the source code of the software systems. The code cleaning is the process associated with writing the clean source code with minimum redundancy to achieve the higher performance. The code clone detection finds the regions with redundancy and the refactoring methods are utilized for the removal of the redundancy from the source code files. In this paper, the major focus has been kept at the clone detection with high accuracy by using the divide and conquer method, which is associated with the segmentation of the code blocks, which is followed by the template matching technique for the feature description from the given source code. The divide and conquer method will be capable to divide the code in the smaller blocks which would undergo the feature extraction for the dilution of the user declarations, which adds the uniqueness to the code segments. The user declarations are converted to the transparent entities by using the standard definition for the entities. The code cloning methods are usually categorized as the blind match detection algorithms, because they extract the training and testing data from the submitted source and do not hold any pre-determined source data. The proposed model will match each and every segment of code against every other segment. The exact matches would be extracted, notified and finally arranged in the cod clone database. The proposed model will track the code clones and perform the refactoring over the detected code clones. The refactoring method will utilize the segment level clone removal from the given source code. The segments extracted and marked under the code cloning methods would be evaluated, and the clones in the higher order classes will be preferred over the child classes. The proposed model is expected to solve the problems associated with the existing models in removal of the clones using the refactoring methods. Keywords: Adaptive clone detection, refactoring, blind clone detection, code cleaning.