Search

A dynamic slicing algorithm is proposed in this paper along with its implementation which is dynamic for concurrent Component-oriented programs carrying multiple threads. As a part of representing the concurrent COP (CCOP) effectively, an intermediate graph is developed called Concurrent Component Dependency Graph (CCmDG). The system dependence graph (SDG) for individual components and interfaces are integrated to represent the above intermediate graph. It also consists of some new dependence edges which have been triggered for connecting the individual dependence graph of each component with the interface. Based on the graph created for the CCOP, a dynamic slicing algorithm is proposed, which sets the resultant by making the executed nodes marked during run time in Concurrent Components Dynamic Slicing (CCmDS) appropriately. For checking the competence of our algorithm, five case studies have been considered and also compared with an existing technique. From the study, we found that our algorithm results in smaller and precise size slice compared to the existing algorithm in less time.

The process of software testing can be divided into two phases, first is the testing of software where we search for bugs in the software and second is the software debugging which helps to find the root cause of the bug. Finding and correcting the bug takes much more time and effort than coding. In this paper, we present a study of different existing debugging techniques and their classifications. We found that most of the debugging techniques are manual, but the spectrum-based debugging technique is automatic. The spectrum-based software debugging is based on statistical formulas. Hence, we have presented the implementation and comparison of the six widely used statistical formulas and developed a debugging tool for JAVA programs.

Traditional waterfall or iterative waterfall methods are being used in software industries since its birth. In the last decade, time to market and flexibility in accommodating customer requirements became very important aspects in software project delivery. Keeping these two driving factors in mind, agile methodology became very popular, where continuous cycle of development and testing involving high customer interaction is promoted and this practice results in an early time to market. Hence, the quality aspects for these projects become very important in today’s context. Quality metrics play an important role in software engineering as they transform both the customer expectation and operational performance to metrics which can be measured, evaluated and compared. These metrics focus primarily on three aspects: the quality aspects of the product, the process which was followed during its development and some important project parameters. These metrics are influenced by different factors such as functionality, usability, reliability and portability. This research work focuses on literature survey on different quality metrics used in traditional software development, their applicability in agile method and finally searches for the right kind of quality metrics which can be used in agile projects.

In this paper, we have proposed an algorithm for dynamic slicing of concurrent COPs that consist of multiple threads. In order to portray the concurrent COP effectively, an intermediate representation graph called concurrent component-oriented dependency graph (CCmDG) is developed based on the dependencies among all the edges. The intermediate representation graph developed for component-oriented programs consists of system dependence graph (SDG) for individual components, along with that some new dependence edges are introduced that are used to connect each system dependency graph to the interface. Based on the intermediate graph created in first step, a dynamic slicing algorithm is proposed for undertaken case study for the concurrent component-oriented program. The resultant is a graph marking and unmarking the executed nodes in concurrent components dynamic slicing (CCmDS) appropriately during run-time.

Traditional fault localization techniques are well equipped for identifying faults in sequential programs. Faults in concurrent programs are caused due to interleaving of the threads during run-time. Finding the faults in concurrent programs are more difficult in comparison with sequential programs. In this paper, we have proposed a fault localization framework based on spectrum-based fault localization for concurrent programs to find the faults occurs during execution of multiple threads. The technique finds the most suspicious function or branch for effective fault localization. We have tested the proposed the technique with two different concurrent example programs to check the accuracy of the technique.

Now-a-days, failure of the software is unavoidable due to increasing size and complexity of software. So, fault finding is necessary for removing the software faults. Spectrum-based fault localization is most popular technique to find the faulty statements of a given program. Still, there are some limitations also. In case of large software, it is very hard and time taking to test all possible scenarios via traditional approach. The machine learning model is an interesting approach for solving this. Recently, deep learning is widely used for improving the fault finding techniques. Deep learning models are based on the architecture of neural network. The neural network architectures based on input layer, hidden layer(s) and output layer. Convolution Neural Network (CNN) is a well-known architecture for deep learning. The network is trained with large amounts of data and neural network architectures that learn the features directly from the information. So, there is no need of manual feature extraction. This technique can capable of finding the suspicious score of each program statement. Using this technique, we can collect the large amount of data from the test cases and extract the important features. As pooling layer of CNN model reduces the input size and complexity of the model, so it speeds up the training process. This framework can also be able to calculate the suspicious score of each statement and accordingly assign the rank.

In software engineering, debugging is a most tedious job. Finding and correcting the bug takes much more time and effort than coding. Many researchers have worked for making the debugging process easier. Many existing debugging techniques are available. Here, in this paper, we review various new emerging trends of software debugging techniques which is mostly used by the developers or testers for a particular application.

Fault finding is an activity to locate the fault or bug present in a software. It is a very time taking job and needs much more effort if done manually. Hence, automated fault localisation is alway...

In a decade ago software engineering exploration progressively focused on software quality improvement and assessment, however the major of these researchers focus on the internal/development perspective i.e. they did not consider users point of views. Nevertheless users mainly attention in the quality of performance intended functions efficiently without knowing how the software product is developed, how work form inside, or its internal quality. The achievement of software companies is totally relies upon the users satisfaction, which they choose to use a software product or not. Hence, in software development strong attention must given to users satisfactions. Software Quality research on users satisfaction help the developers to develop a software that meet users requirements and accepted by end users. In this article based on well known software quality models and the users of software product we intended to discuss the factors as well as sub factors of software quality that influence user's satisfactions.

Component- Oriented Program slicing is a program analysis technique that reduces the complexity in software engineering activities such as software debugging, testing by focusing on inherent aspects of the program. This paper proposes a slicing algorithm to compute the slice of Component - Oriented Programs (COP). To achieve this objective, first we have proposed a intermediate representation called Component Dependency Graph (CmDG). Next, we have proposed the slicing algorithm based on proposed intermediate graph. Then, we have presented a theoretical comparative study of our proposed slicing algorithm with one of the existing slicing algorithms.

In this paper, we propose a technique to compute the dynamic slice of UML models for aspect-oriented software. The UML architectural model for aspect-oriented software represents the 'core' components, 'aspectual' components and the relationship between them. Firstly, we construct aspect-oriented model dependence graph (AOMDG) as an intermediate representation of the UML model for aspect-oriented software. AOMDG is a combination of aspect-class dependence graph (ACDG) and aspect-sequence dependence graph (ASDG). ACDG is constructed by using a set of class and set of aspect class diagrams and ASDG is constructed by using a set of sequence and aspect sequence diagrams from the UML architectural model. Then, we propose an algorithm to compute the dynamic slice by traversing AOMDG by marking and unmarking the nodes for a particular scenario during run-time.

Web applications are broadly utilised for spreading business around the globe. To meet the necessities of the huge numbers of users or customers, the web applications must have better quality and robustness than any other applications where the number of users is limited. Program slicing is found to be useful in improving program understanding, analysis, testing and maintenance. This paper presents a context-sensitive slicing technique for web applications. In this paper, a new intermediate representation called web dependence graph (WDG) is proposed for representing all dependencies that may present in a web application. We have proposed a context-sensitive web slicing (CSWS) algorithm for computation of slices of a given web application using the WDG. A tool is developed for automatic generation of the WDG for a given web application and computation of slices. During our literature survey, we noticed that majority of the automatic graph generation tools are mainly based on byte-code whereas our tool uses the dependency analysis from the source code of the given program. Using our tool WDG, we compared the performance of our proposed CSWS algorithm for slicing with other closely related slicing techniques.

The industries are giving more attention on software quality improvement and assessment, however the majority of researches has been done in the field of internal quality improvement. But, less attention has been given to the user's prospective to improve the quality of a software. The users want the best quality in the usability. The achievement of software companies totally relies upon the user's satisfaction. We focus on customer perspectives of software quality. In this article, first we present some of the existing software quality metrics and their uses. Then, we have accumulated most of the software quality metrics from the literature and prepared a bunch of 27 metrics. Then, we have conducted a survey, with our university students, on the user's perspective to rank the important software quality factors. Based on their responses, we have proposed a new quality model which is user's perspective quality model.

The present investigation concerns the development of floating matrix tablets of metoclopramide hydrochloride (MHCl) for improving its bioavailability by prolonging gastric residence time. Floating matrix tablets (FMT) of MHCl were prepared using the polymers guar gum (GG), karaya gum (KG), HPMC E15 (HE) alone and in combination with HPMC K15M (HK) and gas generating agents such as calcium carbonate and citric acid. The fabricated tablets were evaluated for their physical characteristics such as hardness, drug content, buoyancy, swelling properties and in vitro release studies in 0.1N HCl. The tablets without gas generating agents and HK did not float at all whereas tablets with gas generating agents and without HK floated for 2.33-5.48 h then eroded completely and exhibited faster drug release. Tablets with gas generating agents and HK floated for 24 h without complete erosion and showed slower drug release. This indicates that gas generating agents contributes towards the initial floating of tablets and faster drug release and HK for maintaining the integrity of the FMT and sustaining the drug release. The increase in the concentration of HK in FMT from 10 mg to 40 mg resulted in decrease in release rate of drug. The possibility of drug polymer interaction was determined by differential scanning calorimetry (DSC) and fourier transform infrared (FTIR) spectrometer, and confirmed no interaction between drug and polymers. The release pattern of prepared tablets followed Higuchi kinetics which confirms release mechanism by diffusion.

Software restructuring is essential for maintaining software quality. It is a usual practice that we first design the software and then go for coding. After coding, if there is any change in the requirement or if the output is incorrect, then we have to modify the code again. For each small code modification, it is not feasible to alter the design. These minor changes made to the code causes decay in the software design. Software refactoring is used to restructure the code to improve the design and quality of the software. In this paper, we propose an approach for performing code refactoring. We use slice-based cohesion metrics to identify the target methods that require refactoring. After identifying the target methods, we use program slicing to divide the target method into two parts. Finally, we use the concept of aspects to alter the code structure in a manner that does not change the external behaviour of the original module.

This paper presents a context-sensitive dynamic slicing technique for concurrent AOPs having multiple threads. To effectively represent the concurrent AOP, we propose an intermediate graph called Multithreaded Aspect-Oriented Dependence Graph (MAODG). Based on this intermediate representation, we design a precise and accurate dynamic slicing algorithm for concurrent AOPs. This algorithm takes the MAODG of the concurrent AOP and a slicing criterion as input and computes the dynamic slice for the given concurrent AOP.