Search

Analogy-Based Estimation (ABE) is one of the promising estimation models used for predicting the software development effort. Researchers proposed different variants of the ABE model, but still, the most suitable procedure could not be produced for accurate estimation. In this study, an artificial Bee colony guided Analogy-Based Estimation (BABE) model is proposed which ensembles Artificial Bee Colony (ABC) with ABE for accurate estimation. ABC produces different weights, out of which the most appropriate is infused in the similarity function of ABE during the stage of model training, which are later used in the testing stage for evaluation. There are six real datasets utilized for simulating the model procedure. Five of these datasets are taken from the PROMISE repository. The predictive performance is improved for BABE over the existing ones. The most significant of its performance is found on the International Software Benchmarking Standards Group (ISBSG) dataset.

Functional and non-functional requirements are important equally in software development. Usually, the requirements are expressed in natural languages. The functional and non-functional requirements are written inter-mixed in software requirement document. The extraction of requirement from the software requirement document is a challenging task. Most of the recent studies adopted a supervised learning approach for the extraction of non-functional requirements. However, there is a drawback of supervised learning such as training of model and retrain if the domain changed. The proposed approach manipulates the textual semantic of functional requirements to identify the non-functional requirements. The semantic similarity is calculated based on co-occurrence of patterns in large human knowledge repositories of Wikipedia. This study finds the similarity distance between the popular indicator keywords and requirement statements to identify the type of non-functional requirement. The proposed approach is applied to PROMISE “NFR dataset.” The performance of the proposed approach is measured in terms of precision, recall and F-measure. Furthermore, the research applies three pre-processing approaches (traditional, part of speech tagging and word augmentation) to increase the performance of NFR extraction. The proposed approach outperforms the results of existing studies.

The accuracy of effort estimation in one of the major factors in the success or failure of software projects. Analogy-Based Estimation (ABE) is a widely accepted estimation model since its flow human nature in selecting analogies similar in nature to the target project. The accuracy of prediction in ABE model in strongly associated with the quality of the dataset since it depends on previous completed projects for estimation. Missing Data (MD) is one of major challenges in software engineering datasets. Several missing data imputation techniques have been investigated by researchers in ABE model. Identification of the most similar donor values from the completed software projects dataset for imputation is a challenging issue in existing missing data techniques adopted for ABE model. In this study, Fuzzy C-Mean Imputation (FCMI), Mean Imputation (MI) and K-Nearest Neighbor Imputation (KNNI) are investigated to impute missing values in Desharnais dataset under different missing data percentages (Desh-Miss1, Desh-Miss2) for ABE model. FCMI-ABE technique is proposed in this study. Evaluation comparison among MI, KNNI, and (ABE-FCMI) is conducted for ABE model to identify the suitable MD imputation method. The results suggest that the use of (ABE-FCMI), rather than MI and KNNI, imputes more reliable values to incomplete software projects in the missing datasets. It was also found that the proposed imputation method significantly improves software development effort prediction of ABE model.

Software testing is a vital and complex part of the software development life cycle. Optimization of software testing is still a major challenge, as prioritization of test cases remains unsatisfactory in terms of Average Percentage of Faults Detected (APFD) and time execution performance. This is attributed to a large search space to find an optimal ordering of test cases. In this paper, we have proposed an approach to prioritize test cases optimally using Firefly Algorithm. To optimize the ordering of test cases, we applied Firefly Algorithm with fitness function defined using a similarity distance model. Experiments were carried on three benchmark programs with test suites extracted from Software-artifact Infrastructure Repository (SIR). Our Test Case Prioritization (TCP) technique using Firefly Algorithm with similarity distance model demonstrated better if not equal in terms of APFD and time execution performance compared to existing works. Overall APFD results indicate that Firefly Algorithm is a promising competitor in TCP applications.

Web engineering is a systematic approach to develop web applications, and numerous web engineering methods have been proposed. These methods were extended through defining new models by using different mechanisms to capture the web application concepts. Due to the complexity rising of web applications, the web engineering methods cannot provide web solutions anymore. Even though Interaction Flow Modeling Language (IFML) is recently proposed as a new method for developing web applications, it has limitations. Therefore these methods need to be improved. In this paper, we present the ability of IFML extensibility to support new concerns from web applications. Moreover, we extend IFML through UML mechanisms to support new concerns from the context to the user interface. The new IFML solves the lack of context web application through defining a new model and becomes a new direction to develop concerns modern web applications.

Regression test case selection techniques attempt to increase the testing effectiveness based on the measurement capabilities, such as cost, coverage, and fault detection. This systematic literature review presents state-of-the-art research in effective regression test case selection techniques. We examined 47 empirical studies published between 2007 and 2015. The selected studies are categorized according to the selection procedure, empirical study design, and adequacy criteria with respect to their effectiveness measurement capability and methods used to measure the validity of these results. The results showed that mining and learning-based regression test case selection was reported in 39% of the studies, unit level testing was reported in 18% of the studies, and object-oriented environment (Java) was used in 26% of the studies. Structural faults, the most common target, was used in 55% of the studies. Overall, only 39% of the studies conducted followed experimental guidelines and are reproducible. There are 7 different cost measures, 13 different coverage types, and 5 fault-detection metrics reported in these studies. It is also observed that 70% of the studies being analyzed used cost as the effectiveness measure compared to 31% that used fault-detection capability and 16% that used coverage.

Increasing data recorded in massive open online course (MOOC) requires more automated analysis. The analysis, which includes making student’s prediction requires better strategy to produce good features and reduces prediction error. This paper presents the process of feature engineering for predicting MOOC student’s performance utilizing deep feature synthesis (DFS) method. The experiment produces features which all the top features selected using principal component analysis (PCA) are the features that are generated from method. In terms of prediction comparing both based features and generated features, the result shows better accuracy for generated features proposed using k-nearest neighbours technique which shows the method potential to be used for future prediction model.

Model-driven code generation allows rapid generation of precise code thus reducing the development effort and the delivery time. Consequently, model-driven code generation has been a topic of interest in varying perspectives. While model-driven code generation has been explored well in many domains, its full potential has not been exploited in the context of aspect-oriented software development. The existing approaches have mainly focused on code generation from class diagrams only. Code generation from class diagrams is straightforward as majority of the constructs involved in these diagrams are directly mapped to those in programming languages. However, code generated using class diagrams is limited to skeletons of classes and methods only and does not contain behavior. In this study, we use the state diagrams and propose a mapping of its constructs to AspectJ language. We use the Reusable Aspect Models notation for this purpose. The approach addresses the mapping of both structure and behavior, however, owing to their strength with respect to modeling the system behavior, it essentially focuses on the state diagrams encapsulated in these models. A detailed mapping of different features of the state diagrams is proposed. The approach is illustrated by means of aspect models and corresponding mapped code from an aspect-oriented implementation of a Remote Service Caller example. The implementation shows that the approach can effectively be applied to obtain code for complete structure and behavior modeled using Reusable Aspect Models.

Adaptive learning has become popular among researches in the recent decade. It is believed in giving good benefits which promotes effective ways or methods to improve youth performance in education either for computing field or any non-computing fields. This study focuses on investigating the contribution of adaptive learning in computing education including the adaptation environment involved. This systematic mapping study was undertaken to analyse all relevant and related studies. A set of three research questions were defined in which 68 primary studies, dated from 2012-2020, were analysed and evaluated. The mapping shows the trends and the taxonomy of the contribution adaptive learning in computing education. However, the result also can be applied for non-computing education field. Most of the studied areas are on providing adaptive learning environment and investigating the suitability of learning contents for the youth in teaching and learning. This study summarized the existing research of adaptive learning over past seven years and there is a potential for more research in this area.

Non-Functional Requirements (NFR) are embedded in functional requirements in requirements specification docu-ment. Identification of NFR from the requirement document is a challenging task. Ignorance of NFR identification in early stages of development increase cost and ultimately cause the failure of the system. The aim of this approach is to help the analyst and designers in architect and design of the system by identifying NFR from the requirements document. Several supervised learning-based solutions were reported in the literature. However, for accu-rate identification of NFR, a significant number of pre-categorized requirements are needed to train supervised text classifiers and system analysts perform the categorization process manually. This study proposed an automated semantic similarity based approach which does not needs pre-categorized requirements for identification of NFR from requirements documents. The approach uses an application of Word2Vec model and popular keywords for identification of NFR. Performance of approach is measured in term of precision-recall and F-measure by applying the approach to PROMISE-NFR dataset. The empirical evidence shows that the automated semi-supervised approach reduces manual human effort in the identification of NFR.

Soft Computing based estimation by analogy is a lucrative research domain for the software engineering research community. There are a considerable number of models proposed in this research area. Therefore, researchers are of interest to compare the models to identify the best one for software development effort estimation. This research showed that most of the studies used mean magnitude of relative error (MMRE) and percentage of prediction (PRED) for the comparison of their estimation models. Still, it was also found in this study that there are quite a number of criticisms done on accuracy statistics like MMRE and PRED by renowned authors. It was found that MMRE is an unbalanced, biased, and inappropriate performance measure for identifying the best among competing estimation models. The accuracy statistics, e.g., MMRE and PRED, are still adopted in the evaluation criteria by the domain researchers, stating the reason for “widely used,” which is not a valid reason. This research study identified that, since there is no practical solution provided so far, which could replace MMRE and PRED, the researchers are adopting these measures. The approach of partitioning the large dataset into subsamples was tried in this paper using estimation by analogy (EBA) model. One small and one large dataset were considered for it, such as Desharnais and ISBSG release 11. The ISBSG dataset is a large dataset concerning Desharnais. The ISBSG dataset was partitioned into subsamples. The results suggested that when the large datasets are partitioned, the MMRE produces the same or nearly the same results, which it produces for the small dataset. It is observed that the MMRE can be trusted as a performance metric if the large datasets are partitioned into subsamples.

Rich Internet Applications (RIAs) became to standard of interactive web applications on the internet fastly. It is a complex application with a rich user interface that distributed the data between client and server also allowing an asynchronous communication between them, but web engineering methods are not able to design and implement these features impeccably. The recent web engineering method is Interaction Flow Modeling Language (IFML) which adopted by Object Management Group (OMG). It has many features for developing interactions in web application compared with other web engineering methods but also has limitation for designing RIA features. In this paper, we enhance IFML method through extension the metamodels by using UML extension mechanism, in which, we define new IFML metamodel and some new elements to cope RIA features designing in data distribution between client and server. The results show that this enhancement enables IFML to develop the new types of web applications efficiently.

Several scenario description languages and associated behaviour synthesis processes have been developed. The goal of these is to synthesize behaviour models from system requirement specifications, in order to enable the early identification of weak design spots or code generation. To date, however, most of the scenario languages are poorly scaled with regards to system sizes. This is because scalability requires more expressive constructs that can help when writing a scenario specification in a concise and compact manner, thereby resulting in a reduced number of scenarios. Furthermore, due to a lack of expressiveness in scenario languages, synthesis algorithms may need to rely on global behaviour models to determine inter-scenario dependencies. The global model is an additional factor that limits the approaches' scalability. The reason is that the construction of a global model becomes harder as the system specification increases. To tackle these issues, within this article is proposed an expressive scenario description language that provides a concise and compact approach to scenario description, and defines inter-scenario dependencies semantically. A new algorithm that can address the additional constructs of the language was defined, in order to synthesize component-centric behaviour models. The applicability of this work has been demonstrated through both an illustrative example and a real-world case study. The evaluation indicates that the proposed scenario description language is more scalable than existing languages.

Software requirements engineering is a critical discipline in the software development life cycle. The major problem in software development is the selection and prioritization of the requirements in order to develop a system of high quality. This research analyzes the issues associated with existing software requirement prioritization techniques. One of the major issues in software requirement prioritization is that the existing techniques handle only toy projects or software projects with very few requirements. The current techniques are not suitable for the prioritization of a large number of requirements in projects where requirements may grow to the hundreds or even thousands. The research paper proposes an expert system, called the Priority Handler (PHandler), for requirement prioritization. PHandler is based on the value-based intelligent requirement prioritization technique, neural network and analytical hierarchical process in order to make the requirement prioritization process scalable. The back-propagation neural network is used to predict the value of a requirement in order to reduce the extent of expert biases and make the PHandler efficient. Moreover, the analytical hierarchy process is applied on prioritized groups of requirements in order to enhance the scalability of the requirement prioritization process.

With the evolution of modern web applications, several web engineering methods proposed to develop web applications. The modern web applications are; Rich Internet Application (RIA), Semantic Web Application (SWA), Ubiquitous Web Applications (UWA), and Intelligent Web Applications (IWA), with each of them having new features. The problem is that current web engineering methods cannot support new features of modern web applications. However, some of them extended for new concern of web applications but have limited, meaning these methods have a lack of adaptability to support features from modern web applications. In an attempt to solve this gap, we have defined a new adaptive model for the web engineering methods that can support the new features of modern web applications. This model very efficient in the process development and will be to increase the usability of the methods.

Emerging technologies in education in these recent years have constantly impacted teaching and learning. One of those emerging technologies for teaching nowadays is using robotics. In the field of engineering and technology, programming is one of the most vital and challenging skills to learn. Programming can be tough for novices especially for those who have not acquired any basic programming skills. Robots have been used in the past few years to support the teaching of programming. Researchers have found that students are more interested in programming through robots utilization in teaching compared to traditional teaching methods. Therefore, this study has proposed a way for teaching and learning of programming to be more effective through adapting an existing Project-Oriented Problem-Based Learning (POPBL) framework. Most research works in the past have only implemented the teaching of programming using robotics through a Problem-Based Learning (PBL) framework without considering a systematic PBL framework. Thus, this work aims to study the effectiveness of using a mobile robot known as ‘RoboKar’ as a tool to support the learning of introductory programming by adapting an existing POPBL framework. The effectiveness of the adapted framework was assessed by evaluating three categories of learning comprising analytical and problem solving, learner's knowledge, as well as, collaborative learning. Our study results showed that by adapting a POPBL framework, students can acquire a better understanding in learning introductory programming concepts.

In this paper a systematic review is conducted to investigate the structure, components, techniques, evaluation procedure, and comparison scope related to prior ABE-based studies. The undeniable role of accurate development effort estimation in the success of software project management has attracted the attention of researchers over the past few years. Among various algorithmic and non-algorithmic estimation methods, analogy based estimation (ABE) is a widely accepted method due to its simplicity and estimation capability. This paper investigates the improvement process of ABE method during 2000 to 2012. Six research questions are defined to be addressed through evaluation of prior ABE-based studies. The review domain includes 24 papers selected through a tough filtration process. The results show that improvement of ABE can be performed through adjustment, grey theory, attribute weighting and attribute selection techniques. Moreover, ABE configurations can significantly affect the results.

This paper proposes an improved Latent Semantic Indexing (LSI) with Term Frequency-Inverse Document Frequency (TFIDF) variant for software traceability. The main advantage of the method is the simplicity and accuracy of the algorithm such that it can produce high precision and recall. The accuracy of tracing precise links between software artefacts is achieved by feeding the LSI with TF-IFDF variant that halves the TF and IDF values, thus increases the probability of yielding precise links. To test the accuracy of the proposed method, two case studies were evaluated, namely Mushroom Management System (MMS) and Robotic Wheelchair System (RWS). The superiority of the proposed method over a conventional LSI is confirmed by 409.09%, 900.00%, and 620.00% improvements for precision, recall, and harmonic mean scores, respectively, in MMS case study, at cosine threshold of 0.94. It is anticipated that the method could be beneficial in the design of a practical and accurate system for retrieving precise software traceability links.

The integration of aspect oriented modeling approaches with model-driven engineering process achieved through their direct transformation to aspect-oriented code is expected to enhance the software development from many perspectives. This study aims to assess the existing UML-based aspect-oriented modeling techniques from the perspective of their suitability with regards to integration into model-driven engineering process through aspect-oriented code generation. For this purpose, we selected two mature aspectoriented modeling approaches, Reusable Aspect Models and Theme/UML, and proceeded to evaluate them in a detailed way from the specific perspectives of design and its mapping to the implementation code. The in-depth comparison reveals some points equally shared by both approaches, and identifies some areas where one has advantage over the other. The study concludes that the Reusable Aspect Models approach may be seen as a preferred approach to handling the task of integration using aspect-oriented code generation.

Accurate estimation of software development effort is strongly associated with the success or failure of software projects. The clear lack of convincing accuracy and flexibility in this area has attracted the attention of researchers over the past few years. Despite improvements achieved in effort estimating, there is no strong agreement as to which individual model is the best. Recent studies have found that an accurate estimation of development effort in software projects is unreachable in global space, meaning that proposing a high performance estimation model for use in different types of software projects is likely impossible. In this paper, a localized multi-estimator model, called LMES, is proposed in which software projects are classified based on underlying attributes. Different clusters of projects are then locally investigated so that the most accurate estimators are selected for each cluster. Unlike prior models, LMES does not rely on only one individual estimator in a cluster of projects. Rather, an exhaustive investigation is conducted to find the best combination of estimators to assign to each cluster. The investigation domain includes 10 estimators combined using four combination methods, which results in 4017 different combinations. ISBSG, Maxwell and COCOMO datasets are utilized for evaluation purposes, which include a total of 573 real software projects. The promising results show that the estimate accuracy is improved through localization of estimation process and allocation of appropriate estimators. Besides increased accuracy, the significant contribution of LMES is its adaptability and flexibility to deal with the complexity and uncertainty that exist in the field of software development effort estimation.

The estimation of software development effort has been centralized mostly on the accuracy of estimates through dealing with heterogeneous datasets regardless of the fact that the software projects are inherently complex and uncertain. In particular, Analogy Based Estimation (ABE), as a widely accepted estimation method, suffers a great deal from the problem of inconsistent and non-normal datasets because it is a comparison-based method and the quality of comparisons strongly depends on the consistency of projects. In order to overcome this problem, prior studies have suggested the use of weighting methods, outlier elimination techniques and various types of soft computing methods. However the proposed methods have reduced the complexity and uncertainty of projects, the results are not still convincing and the methods are limited to a special domain of software projects, which causes the generalization of methods to be impossible. Localization of comparison and weighting processes through clustering of projects is the main idea behind this paper. A hybrid model is proposed in which the software projects are divided into several clusters based on key attributes (development type, organization type and development platform). A combination of ABE and Particle Swarm Optimization (PSO) algorithm is used to design a weighting system in which the project attributes of different clusters are given different weights. Instead of comparing a new project with all the historical projects, it is only compared with the projects located in the related clusters based on the common attributes. The proposed method was evaluated through three real datasets that include a total of 505 software projects. The performance of the proposed model was compared with other well-known estimation methods and the promising results showed that the proposed localization can considerably improve the accuracy of estimates. Besides the increase in accuracy, the results also certified that the proposed method is flexible enough to be used in a wide range of software projects.

Development effort is one of the most important metrics that must be estimated in order to design the plan of a project. The uncertainty and complexity of software projects make the process of effort estimation difficult and ambiguous. Analogy-based estimation (ABE) is the most common method in this area because it is quite straightforward and practical, relying on comparison between new projects and completed projects to estimate the development effort. Despite many advantages, ABE is unable to produce accurate estimates when the importance level of project features is not the same or the relationship among features is difficult to determine. In such situations, efficient feature weighting can be a solution to improve the performance of ABE. This paper proposes a hybrid estimation model based on a combination of a particle swarm optimization (PSO) algorithm and ABE to increase the accuracy of software development effort estimation. This combination leads to accurate identification of projects that are similar, based on optimizing the performance of the similarity function in ABE. A framework is presented in which the appropriate weights are allocated to project features so that the most accurate estimates are achieved. The suggested model is flexible enough to be used in different datasets including categorical and non-categorical project features. Three real data sets are employed to evaluate the proposed model, and the results are compared with other estimation models. The promising results show that a combination of PSO and ABE could significantly improve the performance of existing estimation models.

Nowadays, software requirements are widely increasing and modern software technologies are rapidly growing. Therefore, planning and managing the software projects are more important as compared to the past. Unsuitable project planning has been the main reason of software project fails in recent years. Estimating is performed at the early stages of project and it is one of the most important activities in software project planning. During the recent years many different methods have been proposed to estimate the software metrics. Software development effort and software size are most important metrics in this field. Since uncertain nature of software projects makes it difficult to estimate the metrics, soft computing techniques have been widely used in software metrics estimation. These techniques can improve the accuracy of estimations in software projects by means of neural networks, genetic algorithm, fuzzy logic and so on. Among all mentioned methods, due to high flexibility and adaptability, neural networks have been used more than the other methods. A comparative study can be useful to discriminate the performance of neural networks regarding the software metrics estimation. In this paper 15 previous research works in term of using neural networks for software estimation were investigated basically. Analyzing the selected research works showed that neural networks can estimate the software metrics more accurate than most common algorithmic methods.

Software Product Line (SPL) describes procedures, techniques, and tools in software engineering by using a common method of production for producing a group of software systems that identical from a shared set of software assets. In SPL, the similarity-based prioritization can resemble combinatorial interaction testing in scalable and efficient way by choosing and prioritize configurations that most dissimilar. However, the similarity distances in SPL still not so much cover the basic detail of feature models which are the notations. Plus, the configurations always have been prioritized based on domain knowledge but not much attention has been paid to feature model notations. In this paper, we proposed the usage of mandatory and optional notations for similarity distances. The objective is to improve the average percentage of faults detected (APFD). We investigate four different distances and make modifications on the distances to increase APFD value. These modifications are the inclusion of mandatory and optional notations with the similarity distances. The results are the APFD values for all the similarity distances including the original and modified similarity distances. Overall, the results shown that by subtracting the optional notation value can increase the APFD by 3.71% from the original similarity distance.

Regression testing of a large test pool consistently needs a prioritization technique that caters requirements changes. Conventional prioritization techniques cover only the methods to find the ideal ordering of test cases neglecting requirement changes. In this paper, we propose string dissimilarity-based priority assignment to test cases through the combination of classical and non-classical textual comparison metrics and elaborate a prioritization algorithm considering requirement changes. The proposed technique is suitable to be used as a preliminary testing when the information of the entire program is not in possession. We performed evaluation on random permutations and three textual comparison metrics and concluded the findings of the experiment.

Software behavioural models that derive from early requirements specifications such as use-case scenarios and properties have proven useful in early analysis and checking of the design correctness of individual components or whole system. However, deriving of these models becomes harder as a system specification grows. Expressive scenario description language that able to compact and concise scenario specifications is one of the solutions can enhance the ability of modeling large requirements specifications. Deriving behaviour models from compacted scenario specifications is a challenge related to this solution. This paper, introduce expressive scenario language and outline a process to derive system behavioural models from scenarios of this language in form of Labelled Transition Systems (LTS). In addition, the paper also covers some discussion of how these derived models can help analysis of software quality attributes.

This paper reports results of an action research conducted in an outreach program aimed at introducing secondary school students to the exciting world of computer programming. The key challenges were to introduce programming and problem solving session that can be done in a very short time (within 1 to 2 hours) and in a fun way. This was achieved by using a physical mobile robot called RoboKar to engage students with the problem solving activities involving programming. From the entry and exit surveys, and facilitators' observations, it can be concluded that the robot platform and the outreach program were able to introduce and spark interest in learning programming among the school students.

Web services composition is a process of creating a new Web service from a set of available Web services. Semi-dynamic Web services composition in Service Oriented Architecture (SOA) consists of designing composition plan by service provider, and automation of Web service discovery and selection at runtime. This research paper describes redundant-free Web services composition in order to reduce execution time and overall cost of the composition process and also improve efficiency of the composition method. To fulfill the needs, this paper uses a linked list data structure called Composition List (CL) to select the ideal services. In addition, a hash table called Available Output Parameters (AOP) is used to find redundant Web services and reject them from Web services composition process.

Integration is one of the most important parts for the complex system like Islamic Banking System (IBS). Most of the Islamic Banking System have becomes in two different parts of financial and deposit part that made IBS to becomes more complex for integration than other type of banking system. Despite to the current technologies ability to integrate different application together, it also makes integrating IBS more complicated due to the poor reusability and loosely coupling in the present technologies and approaches like traditional Enterprise Application Integration (EAI) or Point to Point Web Services (P2PWS). This paper present the concept of Service Oriented Architecture (SOA) based application integration, by proposing an application integration framework for IBS using Enterprise Service Bus (ESB) and Business Process Execution Language (BPEL). The outcome of this paper demonstrates that applying ESB/BPEL in IB that increase the reusability and loosely coupled of IB services.

Aktiviti menguji sama ada sistem masa nyata memenuhi spesifikasi masa dan keserempakan adalah sangat penting. Salah satu bidang penyelidikan dalam bidang keboleh-percayaan perisian ialah teknik formal yang cuba untuk membuktikan kesahihan sesuatu atur cara dengan spesifikasinya. Oleh kerana masa dan keserampakan merupakan aspek yang penting dalam sistem masa nyata, keperluan untuk menggunakan teknik formal sebagai teknik untuk mengesahkan aspek masa dan keserempakan ini adalah amat tinggi. Kertas kerja ini mengkaji proses membina spesifikasi formal untuk sistem masa nyata berskala kecil dengan menggunakan teknik Z. Spesifikasi formal yang dibangunkan di dalam kertas kerja ini diharap dapat membantu proses penganalisisan fasa reka bentuk di awal proses pembangunan sistem. Kertas kerja ini juga diharap dapat menjadi rujukan kepada projek–projek teknik formal yang akan datang terutamanya projek yang berkaitan dengan sistem masa nyata berskala kecil. Kata kunci: Kebolehpercayaan perisian; spesifikasi formal; Z; masa nyata; sistem berskala kecil. The task of checking whether a real–time system satisfies its timing and concurrency specifications is extremely important. One major area of research addressing software reliability aspect is called formal method, which attempts to prove the correctness of programs with respect to system specifications. Since, timing and concurrency properties can very important in the operation of real–time systems, there is a need for applying formal methods to verify timing properties. This paper investigates the process of building a formal specification of a small-scale embedded hard real–time systems using Z. It is expected that the formal specification presented in this paper can provide assistance in analysing design trade–offs early in the development process. It is also expected that this paper can act as the foundation for any upcoming formal methods related project especially for small-scale real–time systems project. Key words: Software reliability; formal specification; Z; hard real-time; small-scale systems

Since software development environments, methods and tools are changing rapidly, the importance of accurate estimations in software projects is increasing significantly. Inaccurate estimations can lead to unpleasant results in the software projects so that many projects are failed at the early stages of the project. During the recent years, numerous estimation methods have been proposed that most of which are based on statistical techniques. Among all existing methods, simplicity of analogy based method makes it so common in this field. Analogy methods usually present accurate estimations but if the level of non normality in the software project datasets is high or type of most project features is categorical, these methods are confronted with inaccurate estimation problem. In this paper, genetic algorithm has been used under a new framework to improve the performance of analogy methods. A large dataset has been employed to evaluate the performance of the proposed method and the results have been compared with the other estimation methods. The results showed that the proposed method outperformed the other methods considerably

Model-driven code generation is being increasingly applied to developing software systems as a result of its recognition as an instrument to enhance the produced software. At the same time, aspect-oriented programming languages have come to the mainstream of software development due to their distinctive features to provide better modularization and separation of concerns. As a consequence of this prevalence and recognition of its impact on improving several software quality factors, different approaches have been proposed in literature to generate aspect-oriented model-driven code. This paper provides a comparative review of some existing approaches and discusses important issues and directions in this particular area. The results of this survey indicate aspect-oriented model-driven code generation being a rather immature area. Majority of approaches address structure diagrams only, a fact that limits them to partial code generation. There is a need for research that incorporates behavior diagrams, in order to achieve long term goal of full code generation from aspect-oriented models.

Software quality analysis is an important part in getting better software systems. Performing software quality analysis during design time enhances design decisions. In order to assist design decisions and the quality analysis, the design model, which is annotated with quality information, must be transformed into analysis model to execute software analysis part. To achieve this purpose, a main idea is to define model transformation that takes some input from design model and transformed into analysis model. However, both model inherits heterogeneous notation and semantic that could be difficult to perform direct model transformation. To solve this shortcoming, the intermediate metamodel, which is based on failure behavior, is defined as to capture the essential quality information particularly for performance and reliability and be able to transform into a multiple analysis model. In this paper, the intermediate metamodel is presented and focusing on the mapping rules for model transformation from design model to intermediate model. First, the design model (annotated sequence diagram) is modeled and then is transformed into intermediate model (output of intermediate metamodel) by following the defined mapping rules. Then, the intermediate model is constructed to obtain failure based behavior factors. The intermediate metamodel is applied on a simple case study to show the applicability of the intermediate metamodel.

The increasing use and reliance on Distributed Embedded Real-Time Systems (DERTS) demand the enhancement of their capabilities. This along with the unique characteristics of DERTS, such as resource constraints, make the design and development more complex. State-of-the-art software development methods like Service-Oriented Computing (SOC) and Model-Driven Development can be used to cope with these complexities. However, both of the methods require the system to be designed at a higher level of abstraction and the details are provided at lower levels. Such design models for DERTS with different levels of abstractions are still currently unavailable. This paper presents four basic design models representing different levels of abstraction, to be used in Service-Oriented DERTS design. The proposed models were applied in the Home Automation domain for verification purposes. This level-by-level modelling does not only simplify the design process, but can also be used as part of a Service-Oriented modelling framework for DERTS. Furthermore, these design models can support service composition during Service-Oriented DERTS development. The service composition modelling would be beneficial for CASE tools development in supporting designers working at different levels of abstraction.

In ERT (Embedded Real Time) software development, software functionality is not the only focus but multi-constraints extra-functionality requirement such as timing, resources constraint, statically predictable, safety-critical, processing power and memory is also important. Besides that, ERT software development involves multi-disciplinary knowledge that includes software, mechanical and electronic engineering fields. To meet these two challenges ERT software development must be able to support the multi-constraint and multi-disciplinary challenges. From this perspective, CBD (Component-Based Development) appears to be one of the appropriate approaches to design the ERT software due to the ability of domain experts to interactively compose and adapt sophisticated ERT software which the decrease of development time and improvement of software quality. Existing component infrastructures used in ERT software development are MARMOT (Component-Based Real-Time Object-Oriented Development and Testing) and PECOS (Pervasive Component System). However, these technologies are not enough to support the two challenges in their CBD activities. This paper discusses about the integration of PECOS and MARMOT by mapping the metamodel of the two technologies and proposing a process model. The aim of the integration is to support methodological CBD software to enable systematic development of ERT software with consideration of multi-disciplinary knowledge and multi-constraint.

Applying software reuse to many embedded realtime systems, such as autonomous mobile robot system poses significant challenges to industrial software processes due to the resource-constrained and realtime requirements of the systems. An approach for early life-cycle systematic reuse for component-based software engineering (ELCRA) of autonomous mobile robot software is developed. The approach allows reuse at the early stage of software development process by integrating analysis patterns, component model, and component-oriented programming framework. The results of applying the approach in developing software for real robots show that the strategies and processes proposed in the approach can fulfill requirements for self-contained, platform-independent and real-time predictable mobile robot.

QoS-aware composition of web services is a business process to achieve functional goals by considering QoS criteria simultaneously. Although there are many composition algorithms taking either a single criterion or multiple criteria into account, a composite service can presumably consist of redundant services. Our proposed algorithm on Web service composition focuses on multiple QoS criteria as well as redundancy of component services at the time of composition. This work aims to reduce execution time, cost, and the number of component services in the composition process. To fulfill this functional goal, we use linked list and hash table data structures to provide the proposed algorithm with a better time complexity.

Applying software reuse to many Embedded Real-Time (ERT) systems poses significant challenges to industrial software processes due to the resource-constrained and real-time requirements of the systems. Autonomous Mobile Robot (AMR) system is a class of ERT systems, hence, inherits the challenge of applying software reuse in general ERT systems. Furthermore, software reuse in AMR systems is challenged by the diversities in terms of robot physical size and shape, environmental interaction and implementation platform. Thus, it is envisioned that component-based software engineering will be the suitable way to promote software reuse in AMR systems with consideration to general requirements to be self-contained, platform-independent and real-time predictable. A framework for component-oriented programming for AMR software development using PECOS component model is proposed in this paper. The main features of this framework are: (1) use graphical representation for components definition and composition; (2) target C language for optimal code generation with resource-constrained micro-controller; and (3) minimal requirement for run-time support. Real-time implementation indicates that, the PECOS component model together with the proposed framework is suitable for resource constrained embedded AMR systems software development.

Recent@, Component-Based Sofiare Enxineering (CBSE) has becoming a poptrlar approach.for developing embedded sofiare. In CBSE, a component model is required to specifY the standards and conventions imposed on developers of components. Indushial cornponent models such as CORBA, CUM and JavaBeans are general!^ not stritable for embedded real-time (ERT) Vstenis. Consequently, a number of component models slritahle for CBSE ofERT sofiare such 0.7 PBO, Koala, PECOS and ReFIex are introduced. Assessments of the PECOS component model were conducted to evaltrate the suitabiliw of PECOS component model for adoption in CRSE of autonomous mobile-robot (AMR) software. The as.~e.ssments emphasize on three requirentent.y: facilitates predictable real-time performance, support for resource constraint systems, and support plarfonn-independent implementation. Three enhancemenlr were proposed for the PECOS component model. These enhancements were implemented on a real m-wheeled mobile robot. and resul~f show that, the PECOS cornponent model together with the proposed modifications can generate application siritable for resource constrained AMR vstem.r, the new mapping of component behavior to tash process can be used to guarantee the nm-time predictabili(v and perjormance, and the new irnplenientation pamework proposed enable plarform independent development of AMR sofiare.

Software development effort is one of the most important metrics that must be correctly estimated in software projects. Analogy-based estimation (ABE) and artificial neural networks (ANN) are the most popular methods used widely in this field. These methods suffer from inconsistent and irrelevant projects that exist in the software project datasets. In this paper, a new hybrid method is proposed to increase the accuracy of development effort estimation based on the combination of fuzzy clustering, ABE and ANN methods. In the proposed method, the effect of irrelevant and inconsistent projects on estimates is decreased by designing a new framework, in which all the projects are clustered. The quality of training in ANN and the consistency of historical data in ABE are improved using the proposed framework. Two large and real datasets are utilised in order to evaluate the performance of the proposed method and the obtained results are compared to eight other estimation methods. The promising results showed that the proposed method outperformed the other methods on both datasets. The performance metrics of mean magnitude of relative error (MMRE) and the percentage of the prediction (PRED) (0.25) have been improved by average of 51 and 127% in the first dataset, as well as 52 and 94% in the second dataset.