Predicting and Accessing Security Features into Component-Based Software Development: A Critical Survey

Component Based Software Engineering (CBSE) provides a way to create a new Component Based Software System (CBSS) by utilizing the existing components. The primary reason for that is to minimize the software development time, cost and effort. CBSS also increases the component reusability. Due to these advantages, software industries are working on CBSS and continuously trying to provide quality product. Usability is one of the major quality factors for CBSS. It should be measured before delivering the software product to the customer, so that if there are any usability flaws, it can be removed by software development team. In this paper, work has been done to evaluate the usability of CBSS based on major usability sub-factors (learnability, operability, understandability and configurability). For this purpose, firstly software metrics are identified for each usability sub-factor and the value of each sub-factor is evaluated for a component based software project. Secondly, overall usability of the software project is evaluated by using the calculated value of each usability sub-factor. Usability for the same project was also evaluated using Fuzzy approach in MATLAB to validate the experimental work of this research paper. It was identified that the value of usability obtained from software metrics and fuzzy model was very similar. This research work will be useful for the software developer to evaluate the usability of any CBSS and will also help them to compare different version of any CBSS in term of their usability.

Cost estimation of maintenance phase is necessary to predict the reliability, improve the productivity, project planning, controlling and adaptability of the software. Accurate estimation makes good understanding between the customer and user. Maintenance plays important role in various software developments like Iterative development, Agile development and Component Based Software Development (CBSD). In the recent year, software development turned into engineering through the introduction of Component Based Software Development. Though there are various models to estimate the maintenance cost of traditional software like COCOMO model, SLIM, Function Point (FP) model but till now there is no such model to estimate the maintenance cost of Component Based Software Development. In this kind of situation there is needed to develop a model to estimate the maintenance cost of Component-Based Software (CBS). This paper presents proposed basic maintenance cost estimation model for Component Based Software on the basis of COCOMO. This model is based on three parameters: Development cost of Component Based Software, ACT (Annual Change Traffic), Technical and Non-Technical factors which affect the maintenance cost of Component Based Software.

Component based software development (CBSD) endeavors to deliver cost-effective and quality software systems through the selection and integration of commercially available software components. CBSD emphasizes the design and development of software systems using preexisting components. Software component reusability is an indispensable part of component based software development life cycle (CBSDLC), which consumes a significant amount of organization’s resources, that is, time and effort. It is convenient in component based software system (CBSS) to select the most suitable and appropriate software components that provide all the required functionalities. Selecting the most appropriate components is crucial for the success of the entire system. However, decisions regarding software component reusability are often made in an ad hoc manner, which ultimately results in schedule delay and lowers the entire quality system. In this paper, we have discussed the analytic network process (ANP) method for software component selection. The methodology is explained and assessed using a real life case study.

Security affects every software component in different types of computing systems. Many vulnerabilities and attacks on software systems are due to security weaknesses in the software itself. During the process of software specification, development, or testing, security issues are either taken into consideration insufficiently or not at all. Such software, due to internal weaknesses is prone to new attacks. By teaching secure software engineering techniques for designing and developing software modules, students would learn systematic secure software development techniques, such as defect detecting and security testing. This paper presents a series of modules that are designed to be integrated into undergraduate software engineering courses from a security perspective. The goal of the modules is to teach the building of robust software security requirements, secure software design and development, and secure software verification through a secure software development lifecycle.

Component-Based Software Development (CBSD) provides a high efficient and low cost way to construct software systems by integrating reusable software components. Although CBSD has already become a widely accepted paradigm, it is still beyond possibility to assemble components easily from commercial-off-the-shelf (COTS) components into one application system. A variety of mismatches between components often impede the integration of COTS components, and component adaptation is becoming a key problem in Component-Based Software Engineering (CBSE). Aiming at this requirement, this paper presents a self-adaptive software architecture (model-based) approach for supporting seamless integration of COTS components. Specifically, we first propose a self-adaptive software architecture model, and then we discuss and exemplify how to eliminate the mismatches between heterogeneous COTS components based on this model. A simplified on-line shopping system is referred throughout the paper to illustrate our approach.

Software development productivity, code quality, and knowledge sharing have all increased dramatically with the use of AI code assistants like GitHub Copilot. These technologies provide real-time suggestions, expedite workflows, and speed up prototyping by utilising massive language models that have been trained on extensive code repositories. However, serious questions about software security, developer dependency, and ethical ramifications are brought up by their increasing use. The advantages and disadvantages of AI code helpers for safe software development are discussed in this study. It highlights how crucial human oversight, frequent security audits, ongoing model upgrades, and conformity to DevSecOps and OWASP guidelines are. In the end, software integrity cannot be jeopardised by including AI into development processes. In an increasingly automated development context, strategic implementation is crucial to maximising AI's benefits while protecting against new risks.

Along with the development of object-oriented technology, component development is gradually extended to commercial off-the-shelf (COTS) components and component-based software development (CBSD) has gradually become the dominant orientation of the field of software engineering. The claims of high reliability need further investigation based on reliability analysis techniques that are applicable to component-based applications. This paper introduces a new reliability analysis technique applicable to high-level designs. The technique is named reliability analysis based on rewrite logic (RABRL). RABRL is specific for component-based software whose analysis is strictly based on its operational profile and specification. Specification based on rewrite logic can be executed with the help of rewrite technique of Maude, driven by test cases designed from the operational profile. By analyzing the execution process with statistics, we can get the transition probability between components and expected number of visits to components approximately. The paper also adapts the probabilistic model "component-dependency graph" (CDG) proposed by Sherif M. Yacoub to model the component-based software, which is named "adapted component-dependency graph" (ACDG). ACDGs are directed graphs that represent components, component reliabilities, transitions, and transition probabilities. Based on ACDGs, an algorithm is presented to analyze the reliability of the application as the function of reliabilities of its components. A simple case study illustrates the applicability of the algorithm. The RABRL is also used to identify critical components.

Budget and schedule savings are the driving factors for the adoption of commercial-off-the-shelf (COTS) software components by software development organizations. The reliance on COTS components has lead to component-based development (CBD) software systems and introduced changes to the software development process and hence software project management responsibilities and roles. This paper introduces a general framework discussion of essential management aspects for CBD, focusing on COTS. Particularly, stakeholders, requirements, component selection and architecture management issues are discussed from different angles. Some CBD management guidelines and best practices for these aspects are outlined in the conclusion. In addition, CBD management challenges are drawn along with some suggestions in the conclusion section.

Many regard widespread development and reuse of software components as one of the next biggest phenomena for software. However, widespread reuse of a software component with poor quality may lead to disasters. Improper reuse of software components of good quality may also be disastrous. Testing and quality assurance is therefore critical for both software components and component-based software systems. This tutorial provides an in-depth look at the technical issues, challenges, managerial aspects, and needs in testing of components and systems. Moreover, this tutorial reports on the recent advances and research efforts in developing new solutions to solve those problems and meet those needs, from the perspectives of component-based software engineering. The tutorial will discuss the state-of-the-art practice, issues, and challenges, new solutions and research efforts in third-party component testing, component-based program validation, and test automation. The targeted audience includes technical managers, software testing engineers, quality assurance people, and development engineers who are working on component-based software projects. The tutorial will be useful for professionals, researchers, and students interested in understanding the general concepts and methods in component testing and component-based software validation. This tutorial assumes that participants have a general understanding of software engineering and software testing methods, and have some working experience in software development and validation.

Secure software development: a prescriptive framework

In this paper, we identify a set of factors that may be used to forecast software productivity and software development time. Software productivity was measured in function points per person hours, and software development time was measured in number of elapsed days. Using field data on over 130 field software projects from various industries, we empirically test the impact of team size, integrated computer aided software engineering (ICASE) tools, software development type, software development platform, and programming language type on the software development productivity and development time. Our results indicate that team size, software development type, software development platform, and programming language type significantly impact software development productivity. However, only team size significantly impacts software development time. Our results indicate that effective management of software development teams, and using different management strategies for different software development type environments may improve software development productivity.

A novel approach for component-based fault-tolerant software development

A methodology for developing component-based software has been provided to improve productivity and maintainability of software development. As software component is used as a reusable software unit in the methodology, well-defined methodology can support development of component-based software with systematical and synthetic processes. In this paper, we suggest a new methodology for developing component-based software with major two processes: a process for component generation and a process for component assembly. Our methodology is also consisted of detailed jobs and introduces core artifacts to be generated in each working phase.

Serious games provide a method for teaching students in an engaging, non-threatening way. To be useful educational tools, these games need to be designed with the lesson objectives in mind. This paper uses the Game Design Matrix to design a game from learning objectives. The lesson objectives focus on software development, security and operations (DevSecOps). DevSecOps requires judging the cost and risk trade offs between secure and unsecured software aspects including code, data and usability; devising a strategy to produce a system under threat; comprehending that partial security may equate to no security; and identifying examples of insecure code and methods of mitigating it. These lesson objectives combined with the teaching environment drive design decisions that produce a game that fits well into a graduate level course in secure software design and development. We evaluate the game in a graduate course on secure software design and development. Learner surveys confirm that DevSecOps conveys the learning objectives in an engaging way.

Methods for Monitoring Productivity in Applicative Software Development