Software Maintenance as Materialization of Common Knowledge

Pengembangan perangkat lunak adalah tugas kompleks dan membutuhkan adaptasi untuk mengakomodasi kebutuhan pengguna. Untuk membuat konsep dan perubahan perangkat lunak, dalam pemeliharaan, sekarang telah dikembangkan lebih mudah dalam pengembangan perangkat lunak, pola model-view-controller, yang merupakan arsitektur yang dapat membantu memfasilitasi dalam pengembangan dan pemeliharaan perangkat luna. Hal ini, karena dalam arsitektur model tiga-lapis, yaitu: tampilan dan pengontrolan dalam pembangunan dilakukan secara independen, sehingga dapat memberikan dahan dalam pengembangan dan pemeliharaan. Selain itu, arsitektur ini juga dapat melihat hal-hal yang sederhana dan menarik bagi pengguna. Software sistem on-line test adalah perangkat lunak yang memerlukan interaksi dengan pengguna, dan pemeliharaan perangkat adaptif. Karena sistem ujian on-line memerlukan pengembangan perangkat lunak untuk mengakomodasi kebutuhan ini berkembang dengan cepat. Makalah ini untuk menganalisis Model-View-Controller dan mencoba pembangunan, untuk menerapkannya dalam pengembangan perangkat lunak sistem pengujian on-line.

Computer‐aided software engineering (CASE) is both a field of study and a marketplace. As a field of study, it is the collection of research and development over many years in software development management, methods, environments, and software tools. In general terms, CASE is the industrialization of software engineering techniques and computer technology to improve and automate the practice of information systems development. It is an integration technology that incorporates software development techniques, tools, and approaches into common and consistent frameworks. CASE draws on technologies from computer‐aided design, software engineering, operating systems, database, networking, and many other computer disciplines. Thus CASE is not principally a field of new invention. Rather, it is a field of application, integration, and synthesis. As a marketplace, CASE represents a diverse set of products and services for software development and systems integration. The acronym CASE is used as an umbrella for a wide variety of claims regarding software tools and software development productivity. Definitions of CASE are given. CASE evironments, automation of analusis, computer‐supported collaboration, apportunities for quality engineering, maintenance and reengineering are discussed.

Many development practices and software tools enable new product development (NPD), yet few empirical studies shed light on the project characteristics and project contexts driving their use. Using a cross-sectional sample of NPD projects, this study examines how project characteristics and availability of information technology (IT) infrastructure relate to the use of NPD practices and software tools. We also examine how the extent of their use is associated with NPD project performance. The results indicate that different project characteristics influence the use of NPD practices and software tools, with project complexity associated with software tool use, but project uncertainty associated with NPD practice use. Also, customer facing IT infrastructure is associated with the use of NPD practices, while manufacturing plant IT infrastructure is associated with the use of design/validation software tools. Moreover, use of NPD practices has a positive association with all project-level performance metrics examined in this study, and as a result, a greater impact on overall market success. In comparison, the performance impacts of software tools appear relatively limited, with only design/validation software tools exhibiting a strong positive association with product performance quality and a weak positive association with time-to-market and responsiveness. Communication/teamwork software tools exhibit no such impact.

In this chapter, I offer some insights into what I learned over the course of my inquiry into the living and learning that took place on the edges of community. I highlight the inconclusive nature of narrative inquiry as well as demonstrate my recognition that in any narrative inquiry we exit as we entered, in medias res, in the middle of things. Even though the inquiry ends, we continue to compose stories and to share those stories. Our understanding is only ever partial in the same way the stories we compose are incomplete, unfinished. In seeking a conclusion that is not a conclusion, then, I contend that experiences are complex and the stories we compose about those experiences are also complex. The insights and wonderings that emerged from the analysis of my own experiences as well as the experiences of my participants shaped themselves into the overlapping areas of identity-making, curriculum making, and community. In particular, I explored the stories people composed from the edges of community; those spaces conventionally described by the dominant narrative as marginalized. The participants discussed in this chapter demonstrated how profoundly they were each impacted by their positioning as marginalized. At the same time, their stories had a strong thread of self-definition that was insubordinate to that positioning. In varied ways, the participants refused to be defined by others or as other. Their experiences suggested that those spaces conventionally thought of as peripheral, the edges, were actually the defining features of communities.

Software developers need to cope with a massive amount of knowledge throughout the typical life cycle of modern projects. This knowledge includes expertise related to the software development phases (e.g., programming, testing) using a wide variety of methods and tools, including development methodologies (e.g., waterfall, agile), software tools (e.g., Eclipse), programming languages (e.g., Java, SQL), and deployment strategies (e.g., Docker, Jenkins). However, there is no explicit integration of these various types of knowledge with software development projects so that developers can avoid having to search over and over for similar and recurrent solutions to tasks and reuse this knowledge. Specifically, Q&A sites such as Stack Overflow are used by developers to share software development knowledge through posts published in several categories, but there is no link between these posts and the tasks developers perform. In this paper, we present an approach that (i) allows developers to associate project tasks with Stack Overflow posts, and (ii) recommends which Stack Overflow posts might be reused based on task similarity. We analyze an industry dataset, which contains project tasks associated with Stack Overflow posts, looking for the similarity of project tasks that reuse a Stack Overflow post. The approach indicates that when a software developer is performing a task, and this task is similar to another task that has been associated with a post, the same post can be recommended to the developer and possibly reused. We believe that this approach can significantly advance the state of the art of software knowledge reuse by supporting novel knowledge-project associations.

Purpose: To analyze and validate the ability of a newly developed software tool to estimate and analyze consensus contours from manually delineated structures by panel of expert radiation oncologists for building reference atlases for radiotherapy and dosimetry practitioners. Method and Materials: Several statistical methods and a graphical user interface were developed as an integral part of an in‐house research treatment planning system. For evaluation purposes, we used three breast cancer CT scans from the RTOG Breast Cancer Atlas Project labeled A, B, and C. All participating physicians contoured specific structures before and after the consensus panel met without the software aid. Differences in the contours were analyzed qualitatively and quantitatively using metrics based on apparent agreement, kappa statistics, and STAPLE estimates by the developed consensus software tool. Estimates of the consensus contours were analyzed for the different structures before consensus and compared with the experts' manual consensus contour. Dice similarity coefficient (DSC) was used for comparative evaluation between the software and the experts' results. Results: Dice similarity calculations for all pre‐consensus STAPLE estimates and the final consensus panel structures reached 0.80 or greater for the heart, left breast, right breast, case A lumpectomy, case B lumpectomy, and the chest wall. The heart, case A lumpectomy, left breast, and right breast all exhibited a DSC greater than 0.90. The highest Dice coefficients were seen in the comparison of the STAPLE estimated left breast contours, which almost reached 0.96 at 100% confidence level. DSCs were in the range of .70 to .79 for the supraclavicular and internal mammary nodes. Conclusion: Using the consensus software tool incorporating several statistical methods allowed excellent ability to create contours similar to the ones generated by expert physicians and provided metrics for the confidence levels of agreement.

Software development, testing, and maintenance tools must yield assurance information in a standardized form. Developers can use this information to argue that the software is adequate for its use and secure enough for the risk. NIST's Software Assurance Metrics And Tool Evaluation (SAMATE) project is developing specifications for software assurance tools. These specifications can include optional features for assurance information reports, encouraging tools to provide them. During maintenance, developers can collect this information to make explicit assurance cases

This paper presents developed engineering software tools used for nonparametric identification of nonlinear dynamical systems based on Volterra models. The polyharmonic test sequences with different amplitudes are used for test procedures in frequency domain. The wavelets application allowed enlarging computational stability of the identification method for measurement noises filtering of received responses and characteristics of the system being identified. The methodology proposed in pervious works and developed software tools applied for construction communication channel models of different orders.

One of the main goals of Software Engineering is to produce software with quality. But with the increasing use of agile methodologies in software development, it is observed that the existing quality assurance models do not adapt easily to these methods. In this context, the objective of this research is to propose critical factors of success (CFS) and tools for software development and management environment using agile methods, focusing on quality. Thus, initially, a literature review was conducted in SCOPUS and SCIELO bases, identifying 21 CFS, which were grouped into three categories: Individual; Organizational; and Technical / Process. Based on these factors, a questionnaire was applied to specialists in software management and development, reaching the sample of 101 respondents, with the most important CFS belonging to the Personal category, which reinforces the need for investment in this area. After this field research, a case study was done in a public company that uses traditional methods, making it possible to propose a development and management environment of software, adding the best practices, tools and CFS with the purpose of improve the quality of delivery of the final product. It was also observed the applicability of the agile Scrum method, allied to Kanban, taking advantage of the best practices of both, and how much was relevant in the context of the company, demonstrating the importance of agile methods to improve the quality and productivity of the whole team, including customers and sponsors. In addition, the present work generates an CFS base for knowledge of the academic community.

This paper describes the development of a framework that integrates engineering software and agile tools based on ontologies and business rules. The aim of this integration is to help project managers specify their own rules of integration between development software and agile tools. This integration circumvents the limitations of on-the-shelf plugins that perform a very basic integration that not only fails to satisfy the complex needs of project managers but also provides insufficient customization possibilities. A formalization of the domain knowledge ontology and its extension are presented. A generic integration algorithm is presented, and some of its performance properties are detailed. To examine the application and validation of the framework, it is deployed for the integration of spacecraft data definition software with issue management systems. This deployment shows how project managers can specify the integration rules that give them the appropriate feedback information at project level after spacecraft data updates. The evaluation of the framework is conducted at two stages. At the time of design, the usability of the framework is evaluated, and it is shown that the general usability criterion is 4.15 on a Likert-type five-point response scale. Additionally, a comparison with on-the-shelf integration plugins shows that less cognitive effort is required from project managers to customize the presented framework integration rules. At run time, the execution time of the presented framework integration algorithm is evaluated. This evaluation shows that even for updates of large data files on the development software, the agile tools are updated following project managers’ integration rules in a reasonable time.

We briefly present a software methodology for safety-critical software, developed over many years to cope with industrial safety-critical applications in the Canadian nuclear industry. Following this we present discussion on software tools that have been used to support this methodology, and software tools that could be used, but have not been used for a variety of reasons. Based on our experience, we also present and motivate a list of high-level requirements for tools that would facilitate the development of safety-critical software using the presented methods, together with a small number of tools that we believe are worth developing in the future.

A software is developed to satisfy some requirements that could change with respect to technology progress or new clients needs. That is why a software evolves continually in order to fit with occurring requirements. Software evolution or maintenance represents a non-trivial issue that should be treated seriously. In fact, according to some studies software maintenance could consume about 80% of software development total cost. In most of works, such issue was treated in a source code level by proposing new techniques and tools that could optimize maintenance cost. In this paper, we treat the same issue but in an earlier phase of software development and exactly in software design. We propose here an UML profile that allows to software developers and designers to carry about maintenance tasks at the design phase in order to predict handling maintenance tasks before happening, to get an historical trace of these tasks and to express explicitly on models some design patterns helping to resolve software maintenance problems in order to make maintenance easier and cheaper.

Unit testing represents a key activity in software development and maintenance. Test suites with high internal quality facilitate maintenance activities, such as code comprehension and regression testing. Several guidelines have been proposed to help developers write good test suites. Unfortunately, such rules are not always followed resulting in the presence of bad test code smells (or simply test smells). Test smells have been defined as poorly designed tests and their presence may negatively affect the maintainability of test suites and production code. Despite the many studies that address code smells in general, until now there has been no empirical evidence regarding test smells (i) distribution in software systems nor (ii) their impact on the maintainability of software systems. This paper fills this gap by presenting two empirical studies. The first study is an exploratory analysis of 18 software systems (two industrial and 16 open source) aimed at analyzing the distribution of test smells in source code. The second study, a controlled experiment involving twenty master students, is aimed at analyzing whether the presence of test smells affects the comprehension of source code during software maintenance. The results show that (i) test smells are widely spread throughout the software systems studied and (ii) most of the test smells have a strong negative impact on the comprehensibility of test suites and production code.

Automated retrieval of consistent documentation for rapid prototyping systems and software maintenance

This comprehensive review examines the link between AI and software development by examining their interplay throughout all development life cycle stages. The research combines insights from current literature and industry practices, to shed light on AI's impact on processes such as requirement analysis, design, coding, and testing. The study uses the Review Paper technique for examination, covering a wide range of sources, including academic databases, research portals, and publications. The seven-week timeframe includes data analysis, a study of the literature, and a critical examination of the implications and effective role of AI. The study indicates that AI is a collaborative tool in software development, based on historical and contemporary technical realities. The study not only gives more detailed knowledge but also establishes the framework for future research. underlining the need for industry-specific AI applications and a better evaluation of developers' experiences. This research acts as a guidepost for industry executives and academics, providing insights into the changing landscape influenced by AI on software development