Search

Changeability is a non-functional property of software that affects the length of its lifecycle. In this work, the microservices architectural pattern and TypeScript are studied through a literature review, focusing on how they enable the changeability of a web application. The modularity of software is a key factor in enabling changeability. The micro-services architectural pattern and the programming language TypeScript can impact the changeability of web applications with modularity. Microservices architecture is a well-suited architectural pattern for web applications, as it allows for the creation of modular service components that can be modified and added to the system individually. TypeScript is a programming language that adds a type system and class-based object-oriented programming to JavaScript offering an array of features that enable modularity. Through discussion on relationships between the changeability of web applications and their three key characteristics, scalability, robustness, and security, this work demonstrates the importance of designing for change to ensure that web applications remain maintainable, extensible, restructurable, and portable over time. Combined, the micro-services architecture and TypeScript can enhance the modularity and thus changeability of web applications.

The software value chain is knowledge-based since it is highly dependant on people. Consequently, a lack of practice in managing knowledge as a resource may jeopardise its application in software development. Knowledge-Based Resources (KBRs) relate to employees’ intangible knowledge that is deemed to be valuable to a company's competitive advantage. In this study, we apply a grounded theory approach to examine the role of KBRs in Agile Software Development (ASD). To this aim, we collected data from 18 practitioners from five companies. We develop the Knowledge-Push theory, which explains how KBRs boost the need for change in ASD. Our results show that the practitioners who participated in the study utilise, as primary strategies, task planning, resource management, and social collaboration. These strategies are implemented through the team environment and settings and incorporate an ability to codify and transmit knowledge. However, this process of codification is non-systematic, which consequently introduces inefficiency in the domain of knowledge resource utilisation, resulting in potential knowledge waste. This inefficiency can generate negative implications for software development, including meaningless searches in databases, frustration because of recurrent problems, the unnecessary redesign of solutions, and a lack of awareness of knowledge sources. © 2022 The Authors open access

Software design patterns are well-known solutions for solving commonly occurring problems in software design. Detecting design patterns used in the code can help to understand the structure and behavior of the software, evaluate the quality of the software, and trace important design decisions. To develop and maintain a software system, we need sufficient knowledge of design decisions and software implementation processes. However, the acquisition of knowledge related to design patterns used in complex software systems is a challenging, time-consuming, and costly task. Therefore, using a suitable method to detect the design patterns used in the code reduces software development and maintenance costs. In this paper, we proposed a new method based on conceptual signatures to improve the accuracy of design pattern detection. So we used the conceptual signatures based on the purpose of patterns to detect the patterns’ instances that conform to the standard structure of patterns, and cover more instances of patterns’ variants and implementation versions of the patterns and improve the accuracy of pattern detection. The proposed method is a specific process in two main phases. In the first phase, the conceptual signature and detection formula for each pattern is determined manually. Then in the second phase, each pattern in the code is detected in a semi-automatic process using the conceptual signature and pattern detection formula. To implement the proposed method, we focused on GoF design patterns and their variants. We evaluated the accuracy of our proposed method on five open-source projects, namely, Junit v3.7, JHotDraw v5.1, QuickUML 2001, JRefactory v2.6.24, and MapperXML v1.9.7. Also, we performed our experiments on a set of source codes containing the instances of GoF design patterns’ variants for a comprehensive and fair evaluation. The evaluation results indicate that the proposed method has improved the accuracy of design pattern detection in the code.

Building software by using machines to create the code automatically is an old idea, and many automated code generation frameworks exist. These implementations are often very context-dependent because of the vast diversity of requirements placed on the desired applications. When the feature set of an application grows, the complexity of the application also grows. Naturally, the more complex the planned software needs to be, the harder it is to automatize its creation. Over the previous years, the zeitgeist of software architecture has turned towards microservices. Modern cloud service providers offer relatively cheap and robust possibilities for hosting small, special purpose software that communicates over networks. It enables the monolithic software of the past to be split into smaller self-contained, very specialized software. This development opens a door for utilizing more code generation as a part of a software development process as the scope of the generated applications gets more focused. In the thesis, the existing software development process in a company Peikko Group was observed and a proposal for a new process for creating software was designed to improve on the existing one. The improved process was designed to utilize code generation to form software components from a set of formally written specifications. The main idea behind the improved process was to design an automation pipeline so the Peikko Group's domain experts' knowledge in construction design could be turned into a cloud-hosted calculation engine applications in hopes to shorten the delivery time of the software, lowering the cost of prototyping and free software engineering resources. The proposed design was tested by creating a calculation engine that can be used to solve a real-life construction design problem. During the implementation phase, the desired calculation engine was specified using definition files that guide the code generation pipeline. The implementation also includes creating the automation pipeline and using it to generate the desired software components based on the specification. The improved process design and the implementation made based on the design were analyzed and found suitable for future development. Some issues regarding used technologies were identified, but the findings indicate promise and encourage for further improvement iterations. Sovellusten koneavusteinen luominen on teemana vanha ja koneavusteisen ohjelmakoodin luontiin tehtyjä ohjelmistokehyksiä on olemassa useita. Koneavusteinen sovelluskehitys on kuitenkin usein varsin syvästi sidoksissa sovellukseen, jonka kontekstissa koodigenerointi tapahtuu. Tämä on seurausta sovellusten koosta ja haluttujen ominaisuuksien määrästä. Kun sovelluksen ominaisuuksien määrä kasvaa, kasvaa myös sovelluksen kompleksisuus. Mitä monimutkaisempi sovellus on, sitä monimutkaisempia työkaluja tarvitaan sen automaattiseen generointiin. Ajan henki ohjelmistokehityksessä on kääntynyt kohti mikropalveluarkkitehtuuria. Modernit pilvipalvelualustat mahdollistavat verrattain halpoja ja robusteja mahdollisuuksia isännöidä pieniä kapean erikoisalan sovelluksia, jotka keskustelevat verkon yli. Mikrosovellusten yleistyminen mahdollistaa vanhantyylisten monoliittisovellusten pilkkomisen ja korvaamisen useilla pienillä itsenäisillä sovelluksilla. Tässä opinnäytetyössä käydään läpi Peikko Group -yhtiön sovelluskehitysprosessia ja suunnitellaan uudenlainen malli parantamaan tätä. Uudistettu sovelluskehitysmalli on suunniteltu hyödyntämään koodigeneraatiota sovelluskomponenttien luomisessa niin, että generointia ohyjaavat formaalit määrittelydokumentit. Uudentyyppisellä prosessilla pyritään tuomaan automaatiota Peikon asiantuntijoiden rakennesuunnitteluosaamisen siirtämiseen laskentapalveluiksi. Tämän toivotaan lyhentävän sovellusten kehitykseen kuluvaa aikaa, madaltavan kynnystä prototyyppien luomiseen sekä vapauttavan ohjelmistokehitysresursseja. Ohjelmistokehitysprosessiehdotelmaa testattiin luomalla laskentapalvelu, joka kykenee ratkaisemaan käytännön esimerkiksi valitun tosimaailman rakennesuunnitteluongelman. Toteutusvaiheen aikana luotiin määrittelydokumentit laskentasovellukselle ohjaamaan koodigeneraatiota. Toteutusvaiheessa luotiin myös tarvittava koodigenerointiautomaatio ja tätä käyttäen luontiin halutut sovelluskomponentit määrittelydokumenttien mukaisesti. Parannettu ohjelmistokehitysmalli ja sen toteutus analysoitiin ja todettiin kehityskelpoiseksi. Toteutusvaiheessa ja tuloksia analysoitaessa löydettiin haasteita, jotka juontavat juurensa käytettyihin teknologioihin. Tulokset täyttivät annetut tavoitteet ja olivat kaiken kaikkiaan lupaavia ja rohkaisevat jatkamaan prosessin ja automaation kehitystä seuraavalle kehitysiteraatiolle.

The learning of software design is known to be a difficult and challenging task for students. This dissertation studies different didactic approaches for learning software design to improve the way we teach students software design. The research in the dissertation questions whether we can assess software design skills, what guidance is needed for the improvement of students’ understanding of software design and how to motivate and engage students for learning software design. The research explores the following: an instrument for measuring software design skills based on design principles, the gamification of learning software design, revealing students’ software design strategies, the use of peer-reflection for uncovering the difficulties students have during software design tasks, the use of teaching assistants as bridge between the lecturer and the students, the automation of grading software designs with machine learning, guiding feedback by a pedagogical agent and a workshop for engaging students into the process of software development. The research contributes to the future education of software design.

The study is primarily aimed at describing how to design and develop a teacher evaluation system for a higher learning institution in Nueva Ecija, Philippines. Specifically, it sought to describe the activities undertaken in the software development lifecycle stages, including planning and requirements analysis, design, development, and testing. Maintenance and deployment stages were not covered in this study. Using developmental research, proponents developed the system following the SDLC stages. The results show how the proponents successfully developed the system. Proponents suggested that future studies may be conducted which may focus on the assessment phase covering deployment and maintenance stages, to learn how end-users and information technology (IT) expertsview the developed system.

Microservices and Big Data are renowned hot topics in computer science that have gained a lot of hype. While the use of microservices is an approach that is used in modern software development to increase flexibility, Big Data allows organizations to turn today’s information deluge into valuable insights. Many of those Big Data architectures have rather monolithic elements. However, a new trend arises in which monolithic architectures are replaced with more modularized ones, such as microservices. This transformation provides the benefits from microservices such as modularity, evolutionary design and extensibility while maintaining the old monolithic product’s functionality. This is also valid for Big Data architectures. To facilitate the success of this transformation, there are certain beneficial factors. In this paper, those aspects will be presented and the transformation of an exemplary Big Data architecture with somewhat monolithic elements into a microservice favoured one is outlined.

In solving the problem of fuzzy application for scheduling delivery of goods with a limited power source and minimal time, the problems that are still not considered in the RCPS problem modeling are the uncertainty characteristics of the parameters of the timing of activities in the delivery project. Even though this can be solved by using the PERT (Project Evaluation and Review Technoloque) method with a probabilistic approach, this technique still ignores the limitations of the supply of resources. Actually, a probabilistic approach can be used, if previously provided data about the experience in completing similar projects. But if the project is a new project or the techniques and methodologies used to complete a new project, such as new techniques and methodologies in software engineering, among others: object-oriented design and programming, computer-aided software design, user interface management systems, fourth generation languages, etc., then the probabilistic approach is not suitable. In this situation, the decision maker must be able to estimate the cost and time duration, of all activities in the project based on existing experience, related to the level of knowledge they have, about new techniques and methodologies to be applied, and the level of human resource expertise. which are available. This method of estimating project costs and time, which is more precise, uses representations in the form of fuzzy numbers, namely fuzzy sets in the set of real numbers that are normal, convex, and closed intervals. The delivery time is modeled as a fuzzy number of LR types IKiri, IKanan, α, β, with three values ​​of α-cuts E = 0.3, L = 0.7, and I = 1.0. The fuzzy transformation model is based on three pairs of inferior and superior values ​​from α-cuts. The priority for scheduling delivery of goods is based on the smallest early start time EST value. Resources are solved by serial and parallel models. The smallest makespan value is used to determine the best solution. Goods delivery settlement uses fuzzy operations, namely arithmetic operations and relation operations. Analysis of the output oftware based on testing with test scenarios (table ^ .50) for some input data shows that the parallel method is better than the serial method. This is indicated by the large difference in makespan value generated from the two methods. Based on input data from a software development project, the serial method gives makespan values ​​in the range between 675.0 and 867.0, while the parallel method gives makespan values ​​in the range between 116.0 and 259.0. The analysis of the output software in a fuzzy Gantt Chart representation shows that an activity can be scheduled with varying degrees of optimism. The degree of optimistic activity scheduling can be graded in linguistic terminology between two extreme pessimistic and optimistic values, namely very pessimistic, pessimistic, slightly pessimistic, slightly optimistic, optimistic, very optomistic.

Future computing architectures will host increasing numbers of cores while also moving toward specialized architectures and accelerators. This development strains hardware and software design, verification, and system validation efforts. This letter introduces a virtual platform (VP) centered design flow that not only enables early software development but also considers a solution for the challenges on hardware and system level. As a core element, a hybrid prototyping framework targeting networks-on-chip (NoC) links for interfacing a VP and a field-programmable gate array provides scalability and accuracy for hardware verification and system validation.

Interface and interaction design take up most of the times in software creation. Human Computer Interaction (HCI) is mainly the best way to interact with a computer. During software development, class diagram is the only required step and process to design an information system according to UML notation. In addition, creating class diagram is a mandatory activity during the software creation process. The aim of this paper is to automatically generate the HCI mockup from class diagram to make easy and extremely fast software design. For example, the SEF (Schema d’Enchainement de Fenetre), is an interface model allowing to create a new interface mockup. It offers more widgets to design the HCI. And MACAO (Methode d’Analyse et de Conception d’Applications Orientees-objets) is one of the methods which helps computer scientist to easily create software. The model transformation is based on Model Driven Engineering (MDE). We use UML notation to design the class diagrams. We also adopt MDA architecture to create the model-based transformation process. Transformation rules are created using Atlas Transformation Language (ATL) to automatically generate a specific interface from the class diagram.

The project management process has been used in the area of Software Engineering to support project managers to keep projects under control. One of the essential processes in Software Engineering is to conduct an accurate and reliable estimation of the required effort to complete the project. This article’s objectives are: i) to identify the variables that influence the estimation based on the correlation, and ii) to apply the Extreme Learning Machine - ELM model for effort estimation and compare it with the literature models. Thus, it was investigated which technique has better effort prediction accuracy. The models were compared with each other based on predictive precision in the criterion of absolute mean residue (MAR) and statistical tests. The main findings in this study were: i) important variables for effort estimation and; ii) the results indicated that the ELM model presents the best results compared to the models in the literature for estimating software design effort. In this way, the use of Machine Learning techniques in the effort estimation process can increase the chances of success in the accuracy of the time estimates and the project’s costs.

The ability of the software to easily understand it is very important, to evaluate the performance of a system or process a certain mechanism is needed. So that the achievement level of software development is obtained, the assessment of code quality and design in the metrics have different contributions to the quality properties of software design. The assessment of software characteristics is described in a model based on the Chidamber Kemerer (CK) Entropy Metrics design property indicator. Measure specific properties of the software by mapping them into numbers according to objective and well-defined measurement rules. To be able to help perform the software quality calculation process based on CK metrics on the eclipse equinox data by using the Mamdani fuzzy inference system, pointing the classification into low which can be interpreted as having good quality. And the value affirmation of the deffuzzyfication method in this case is done by using the COA (center of area) method, to determine the crisp x value, obtained from the membership function formed from the composition process of all outputs.

In most software engineering approaches, software design begins with defining functional requirements, which is well suited to web-based software development projects. When designing high-critical large-scale software intended for industrial use, accounting for non-functional software requirements is also required. The main idea of the proposed document-oriented approach is to design a stable architectural solution as early as possible, taking into account the nonfunctional characteristics of the software: reliability, security, maintainability and performance (quality attributes). At the same time, the key issue is the coordination of functional requirements, taking into account technical limitations and business requirements achieved during the steady interaction of customer and developer teams. To increase the flexibility of the designed solutions and prevent crisis situations when developing highly critical large-scale software, it is proposed to use the approach integrating the architecture-centric design method (ACDM), the architecture-tradeoff analysis method (ATAM) with a matrix enterprise architecture matrix (EAM). This allows getting a result that is adequate to the required level of responsibility and reliability. Consideration of quality attributes within the framework of the method of compromise analysis makes it possible to select and make certain decisions in software design taking into account the scale of the software and its scope. The main attributes of product quality are highlighted (ISO 25010 standard), critical scenarios are defined for each of them (templates and use cases). The use of these templates for detailed software design with the necessary parameters of functional requirements, business conditions and technological limitations reduces the risk of developing unpredictable and uncertain system behavior. Based on the proposed approach, an architectural solution is presented for highly critical, responsible, large-scale software for managing autonomous robotic open-pit mining of minerals. Critical attributes for creating the specified software were identified and ranked, and the architecture of the solution according to the SWEBOK software development standard was described. Further, taking into account the nature, scale and scope of the software solution, recommendations are given on high-level architectural templates for the system design, including layers, pipelines and microservices. The proposed architecture-oriented development method is suitable for industrial-level software in various subject areas.

Due to the widespread proliferation of today’s Internet of Things (IoT), a system designer needs the IoT system and software design patterns to assist in designing scalable and replicable solutions. Patterns are encapsulations of reusable common problems and solutions under specific contexts. Many IoT patterns have been published, such as IoT design patterns and IoT architecture patterns to document the successes (and failures) in IoT systems and software development. However, because these patterns are not well classified, their adoption does not live up to their potential. To understand the reasons, we conducted a systematic literature review. From the 32 identified papers, 143 IoT architecture and design patterns were extracted. We analyzed these patterns according to several characteristics and outlined directions for improvements when publishing and adopting IoT patterns. Of the extracted patterns, 57% are non-IoT patterns, suggesting that IoT systems and software are often designed via conventional architecture and design patterns that are not specific to IoT design. Although most IoT design patterns are applicable to any domain, IoT architecture patterns tend to be domain specific, implying that the unique nature of IoT adoption in specific domains appears at the architecture level. As more domains adopt IoT, the number of domain-specific IoT design patterns should increase. In terms of quality attributes, many IoT patterns address compatibility, security, and maintainability.

IoT (Internet of Things) is an information network of significant objects (machines, Sensors, Actuators, etc.,) that allows interface and collaboration of these objects to reach general goals. More innovations of development environment are needed for Software Engineering (SE) for the Internet of Things. At present recent stimulating trend is expansion environments in the cloud computing to enable the extremely scalable V&V (verification and validation) techniques that will be needed for most large safety critical systems in the Internet of Things. This paper discusses necessary safety activities to Internet of Things (IoT) based software development. Incorporate the IoT with SE practices gives best research on safety Internet of Things (IoT) with SDLC (Software Development Life Cycle) in terms of software requirements, software Design, implementation, testing and maintenance, and afford safety and quality control and assurance actions to IoT(Internet of Things) support s/w development.

This thesis introduces a way to transform from traditional software development to model-based design in the control application domain, specifically PLC-based control systems. Traditional software development refers to a process where code is written directly based on system and module design after system requirements are defined. Model-based re-engineering refers to a process where old software is converted to new implementation using a model-based design methodology. Model-based design is a mathematical and visual method to address complex control system problems and is focused on the design phase of the development process. There are multiple reasons why there is a rising interest to use model-based design instead of traditional development but changing to this development model is problematic. The old codebase is usually done by handwritten code and transforming to model-based and new platforms can be complex. This thesis answers the presented problem by developing a systematic way how this transformation can be done. This is achieved by combining re-engineering with V-model. Furthermore, a case study is performed which uses the introduced process for transforming the reference code into a new implementation using model-based design. This case study focuses on how the verification process evolves when re-engineering is part of the V-model. This case study is completed using proprietary software for the model-based design process known as MathWorks’ Simulink and Simulink PLC-coder. Case study showed that it was possible to create a redesigned software using introduced re-engineering model. As a result of this case study, problems in the re-engineering process and the case study itself are explored and an idea for further study is presented.

Code review is a common practice in software development and numerous studies have described different aspects of the process; its characteristics, the expectations on that process, issues around reviewer allocation, and more. However, one aspect that has not been studied to a large extent is the experience of the developers in the code review process. This is unfortunate given the significant amount of time that developers spend on this activity, where problems that degrade developers' experience on a daily basis can create work environment issues. In this paper, we present an extended analysis of an exploratory mixed-method study where we focus on developers' experience of code review. We use semi-structured interviews to gather data from two multi-national companies and conduct a follow-up survey. Our results suggest that developers are frequently bothered by misalignments in the code review tooling and process which is hindering them in carrying out their code review tasks effectively. We present an initial characterization of misalignments that may hamper the developer experience. Based on our findings, we propose directions for further exploration to improve the developer experience. © 2022 Owner/Author. open access

A ¿decision view¿ provides a useful addition and complement to more traditional sets of architectural views and viewpoints; it gives an explanatory perspective that illuminates the reasoning process itself and not solely its results. This decision view documents aspects of the architecture that are hard to reverse-engineer from the software itself and that are often left tacit. The decision view and the decisions that it captures embody high-level architectural knowledge that can be transferred to other practitioners, merged when systems are merged, and offer useful support for the maintenance of large and long-lived software-intensive systems. This article leads the reader through a succession of epiphanies: from design to architecture, then architecture representation to architecture design methods, and finally to architectural design decisions Ciencias de la Computación

Background/Objectives: The main purpose is to find the significance of Object-Oriented metrics on software design; metrics are related to minimizing class unused attributes and methods to maintain quality and complexity.Methods/Statistical analysis: Experimental analysis is utilized for validating findings. Mathematical properties are used for validation and evaluation outcomes. The purpose of experimental validation is to understand whether a measurement quantifies what it should quantify. MS-Excel is utilized as a metric computation and graph generation for fifteen project designs. Statistical analysis through SPSS tool of different inheritance categories as single, multiple, multilevel, hierarchical, and hybrid are utilized for metric results.Findings: SSAAM is suggested to give measurement results for counting public and protected attributes of all super and subclasses in the class inheritance hierarchy. SSMAM explores numeric value for computing public and protected methods of all super and sub classes in the class inheritance hierarchy. Higher results are computed of SSAAM and SSMAM, it shows more inheritance hierarchy utilized in the design. It assist in a controlled use of public/protected members in software design to minimize complications. Software design complications can be enhanced due to more use of protected and public members as well as decreased use of the concept of encapsulation. Keywords: Metrics; quality; protected and public specifiers