jehanweerasuriya/uni-ai-dataset huggingface dataset:
ONTOLOGY DRIVEN SOFTWARE ENGINEERING: MODELS, METHODS, IMPLEMENTATIONS
Authors: Vladimir F. Khoroshevsky
Published in: Ontology of Designing (2019-12-12)

Ontology-driven software engineering is the scope of the paper. A retrospective analysis of the approaches, models and methods is carried out. In the first section, a brief overview of "classical" technologies, approaches and methods for software engineering is presented. It is shown that the emphasis of research and development is currently shifting from the field of technologies of programming towards the modeling of the software design processes, as well as towards the specifications and testing of the developed systems. It is outlined that the general trend in the domain is the use of methods and tools of ontology modeling of both the design processes per se and the specifications of the developed systems. The second section is devoted to a review of publications in the field of ontology-based software engineering. Such paradigms for modeling software development processes as Software Product Lines, plug-and-play software development - Component-Based Development, model-driven software engineering - Model-Driven Engineering, etc. are discussed. It is shown that "programming through generation", i.e. Generative Programming, is a general approach supporting the considered paradigms. It is shown that R&amp;D in the domain of the semantic models of software engineering is currently focused on a new approach - Ontology-Based (-Driven) Software Engineering. Within the framework of this area, ontology engineering tools are developed along with modeling the software development processes. The scientific and technical perspectives of ontology driven software engineering are specified and discussed in the final part of the paper. In particular, it is outlined that the theoretical foundations of ontology-based modeling of software design processes form the solid basis for shifting the focus from the models of compiling the modules to their pattern-based generation from internal specifications. It is noted that the next trend in the field of OBSE-ODSE will be the usage of machine learning methods and tools to generate ontological models of software design.
Synthesis of probabilistic models for quality-of-service software engineering
Authors: Simos Gerasimou, Radu Călinescu, Giordano Tamburrelli
Published in: Automated Software Engineering (2018-05-17)

An increasingly used method for the engineering of software systems with strict quality-of-service (QoS) requirements involves the synthesis and verification of probabilistic models for many alternative architectures and instantiations of system parameters. Using manual trial-and-error or simple heuristics for this task often produces suboptimal models, while the exhaustive synthesis of all possible models is typically intractable. The EvoChecker search-based software engineering approach presented in our paper addresses these limitations by employing evolutionary algorithms to automate the model synthesis process and to significantly improve its outcome. EvoChecker can be used to synthesise the Pareto-optimal set of probabilistic models associated with the QoS requirements of a system under design, and to support the selection of a suitable system architecture and configuration. EvoChecker can also be used at runtime, to drive the efficient reconfiguration of a self-adaptive software system. We evaluate EvoChecker on several variants of three systems from different application domains, and show its effectiveness and applicability.
Variability and Reproducibility in Software Engineering: A Study of Four Companies that Developed the Same System
Authors: Bente Anda, Dag I. K. Sjøberg, Audris Mockus
Published in: IEEE Transactions on Software Engineering (2008-12-08)

The scientific study of a phenomenon requires it to be reproducible. Mature engineering industries are recognized by projects and products that are, to some extent, reproducible. Yet, reproducibility in software engineering (SE) has not been investigated thoroughly, despite the fact that lack of reproducibility has both practical and scientific consequences. We report a longitudinal multiple-case study of variations and reproducibility in software development, from bidding to deployment, on the basis of the same requirement specification. In a call for tender to 81 companies, 35 responded. Four of them developed the system independently. The firm price, planned schedule, and planned development process, had, respectively, “low,” “low,” and “medium” reproducibilities. The contractor's costs, actual lead time, and schedule overrun of the projects had, respectively, “medium,” “high,” and “low” reproducibilities. The quality dimensions of the delivered products, reliability, usability, and maintainability had, respectively, “low,” "high,” and “low” reproducibilities. Moreover, variability for predictable reasons is also included in the notion of reproducibility. We found that the observed outcome of the four development projects matched our expectations, which were formulated partially on the basis of SE folklore. Nevertheless, achieving more reproducibility in SE remains a great challenge for SE research, education, and industry.
An Experiment in Small-Scale Application Software Engineering
Authors: Barry Boehm
Published in: IEEE Transactions on Software Engineering (1981-09-01)

This paper reports the results of an experiment in applying large-scale software engineering procedures to small software projects. Two USC student teams developed a small, interactive application software product to the same specification, one using Fortran and one using Pascal. Several hypotheses were tested, and extensive experimenal data collected. The major conclusions were as follows.
Software Metrics Validation Methodologies in Software Engineering
Authors: Kannan Srinivasan, T. Rajani Devi
Published in: International Journal of Software Engineering & Applications (2014-11-30)

In the software measurement validations, assessing the validation of software metrics in software engineering is a very difficult task due to lack of theoretical methodology and empirical methodology During recent years, there have been a number of researchers addressing the issue of validating software metrics. At present, software metrics are validated theoretically using properties of measures. Further, software measurement plays an important role in understanding and controlling software development practices and products. The major requirement in software measurement is that the measures must represent accurately those attributes they purport to quantify and validation is critical to the success of software measurement. Normally, validation is a collection of analysis and testing activities across the full life cycle and complements the efforts of other quality engineering functions and validation is a critical task in any engineering project. Further, validation objective is to discover defects in a system and assess whether or not the system is useful and usable in operational situation. In the case of software engineering, validation is one of the software engineering disciplines that help build quality into software. The major objective of software validation process is to determine that the software performs its intended functions correctly and provides information about its quality and reliability. This paper discusses the validation methodology, techniques and different properties of measures that are used for software metrics validation. In most cases, theoretical and empirical validations are conducted for software metrics validations in software engineering .
Systematic Mapping Study on Security Approaches in Secure Software Engineering
Authors: Rafiq Ahmad Khan, Siffat Ullah Khan, Habib Ullah Khan, Muhammad Ilyas
Published in: IEEE Access (2021-01-01)

In the modern digital era, software systems are extensively adapted and have become an integral component of human society. Such wide use of software systems consists of large and more critical data that inevitably needs to be secured. It is imperative to make sure that these software systems not only satisfy the users' needs or functional requirements, but it is equally important to make sure the security of these software systems. However, recent research shows that many software development methods do not explicitly include software security measures during software development as they move from demand engineering to their final losses. Integrating software security at each stage of the software development life cycle (SDLC) has become an urgent need. Tackling software security, various methods, techniques, and models have been suggested and developed, however, only a few of them provide strong evidence for building secure software applications. The main purpose of this research is to study security measures in the context of the development of secure software (SSD) during the study of systematic mapping (SMS). Based on the inclusion and exclusion criteria, 116 studies were selected. After the data extraction from the selected 116 papers, these were classified based on the quality assessment, software security method, SDLC phases, publication venue, and SWOT analysis. The results indicate that this domain is still immature and sufficient research work needs to be carried out particularly on empirically evaluated solutions.
Cognitive heuristics in software engineering applying and extending anchoring and adjustment to artifact reuse
Authors: Jeffrey Parsons, Corinne J. Saunders
Published in: IEEE Transactions on Software Engineering (2004-12-01)

The extensive literature on reuse in software engineering has focused on technical and organizational factors, largely ignoring cognitive characteristics of individual developers. Despite anecdotal evidence that cognitive heuristics play a role in successful artifact reuse, few empirical studies have explored this relationship. This paper proposes how a cognitive heuristic, called anchoring, and the resulting adjustment bias can be adapted and extended to predict issues that might arise when developers reuse code and/or designs. The research proposes that anchoring and adjustment can be manifested in three ways: propagation of errors in reuse artifacts, failure to include requested functionality absent from reuse artifacts, and inclusion of unrequested functionality present in reuse artifacts. Results from two empirical studies are presented. The first study examines reuse of object classes in a programming task, using a combination of practicing programmers and students. The second study uses a database design task with student participants. Results from both studies indicate that anchoring occurs. Specifically, there is strong evidence that developers tend to use the extraneous functionality in the artifacts they are reusing and some evidence of anchoring to errors and omissions in reused artifacts. Implications of these findings for both practice and future research are explored.
Constructivism as guiding philosophy for software engineering education
Authors: Said Hadjerrouit
Published in: ACM SIGCSE Bulletin (2005-12-01)

Within the last few years constructivism has attracted both computer science and software engineer educators, because of its potential for improving academic learning. Currently, however, the application of constructivism is limited to examples in specific contexts so that it is difficult to transfer them to other institutions or even other courses. To apply effectively constructivism to software engineering and computer science education, instructors need a generic pedagogical model for translating constructivist principles into practice. This paper reports on the application of a pedagogical model for translating constructivism into a Web-based course in object-oriented software engineering.
New Age of Software Development: How Component-Based Software Engineering Changes the Way of Software Development ?
Authors: Mikio Aoyama
Published in:  (1998-01-01)

The dawn of a new age of software development is coming. Wide spread of the Internet technology and PCs opened up new market of software as well as new architecture of software. However, conventional software development technology could not catch up with the speed. Component-Based Software Engineering (CBSE) is an emerging paradigm of software development. Its goal is composing applications with plug &amp;amp; play software components on the frameworks. CBSE is aiming at realizing long-waited software reuse by changing both software architecture and software process. It may vastly change the way we develop software. However, we still see many problems to solve. Let&amp;apos;s open up discussions, and take a step toward the new age of software development. Keywords Componentware, Object-Orientation, Reuse, Framework, Java and Distributed Object 1 INTRODUCTION: CHANGE Change is a badge of modern corporate. No corporate can do business without software. Now, change is a badge of software tribe. As il...
Applying Active Methodologies for Teaching Software Engineering in Computer Engineering
Authors: Víctor Flores, Jesica Gomez
Published in: IEEE Revista Iberoamericana de Tecnologias del Aprendizaje (2017-08-01)

The traditional teaching-learning processes used by Chilean universities are changing. This document describes two innovative strategies applied to teach software engineering (SE) at two universities in Chile. Teaching experiences are part of our ongoing effort to improve the current teaching-learning strategies of SE in the mentioned universities. In this paper, we describe our teaching experiences using both problem-based learning (PBL) and an agile software engineering methodology, to achieve learning outcomes and to improve students' participation during classes. We present two ways to correlate the activities of a software project; these activities are tasks of a software methodology and an active learning strategy based on PBL. The strategies used to verify the accomplishment of these goals are also detailed.
PBL-SEE: An Authentic Assessment Model for PBL-Based Software Engineering Education
Authors: Simone C. dos Santos
Published in: IEEE Transactions on Education (2016-09-27)

The problem-based learning (PBL) approach has been successfully applied to teaching software engineering thanks to its principles of group work, learning by solving real problems, and learning environments that match the market realities. However, the lack of well-defined methodologies and processes for implementing the PBL approach represents a major challenge. The approach requires great flexibility and dynamism from all involved, whether in mapping content, in teacher performance, or laying out the process of how learners should go about solving problems. This paper suggests that management processes can help in implementing PBL throughout its life cycle (planning, implementation, monitoring, and enhancement), and proposes an assessment model called PBL-SEE for use in software engineering education (SEE). Two examples of its use are provided. The results show how the model can be applied and how the resulting information can be used to make the PBL initiatives “authentic,” in that they bring the reality of the labor market to the learning environment, while keeping to PBL principles.
Detecting duplicate bug reports with software engineering domain knowledge
Authors: Karan Aggarwal, Finbarr Timbers, Tanner Rutgers, Abram Hindle, Eleni Stroulia, Russell Greiner
Published in: Journal of Software Evolution and Process (2016-10-27)

Bug deduplication, ie, recognizing bug reports that refer to the same problem, is a challenging task in the software‐engineering life cycle. Researchers have proposed several methods primarily relying on information‐retrieval techniques. Our work motivated by the intuition that domain knowledge can provide the relevant context to enhance effectiveness, attempts to improve the use of information retrieval by augmenting with software‐engineering knowledge. In our previous work, we proposed the software‐literature‐context method for using software‐engineering literature as a source of contextual information to detect duplicates. If bug reports relate to similar subjects, they have a better chance of being duplicates. Our method, being largely automated, has a potential to substantially decrease the level of manual effort involved in conventional techniques with a minor trade‐off in accuracy. In this study, we extend our work by demonstrating that domain‐specific features can be applied across projects than project‐specific features demonstrated previously while still maintaining performance. We also introduce a hierarchy‐of‐context to capture the software‐engineering knowledge in the realms of contextual space to produce performance gains. We also highlight the importance of domain‐specific contextual features through cross‐domain contexts: adding context improved accuracy; Kappa scores improved by at least 3.8% to 10.8% per project.
The Future of AI-Driven Software Engineering
Authors: Valerio Terragni, Annie Vella, Partha S. Roop, Kelly Blincoe
Published in: ACM Transactions on Software Engineering and Methodology (2025-01-24)

A paradigm shift is underway in Software Engineering, with AI systems such as LLMs playing an increasingly important role in boosting software development productivity. This trend is anticipated to persist. In the next years, we expect a growing symbiotic partnership between human software developers and AI. The Software Engineering research community cannot afford to overlook this trend; we must address the key research challenges posed by the integration of AI into the software development process. In this article, we present our vision of the future of software development in an AI-driven world and explore the key challenges that our research community should address to realize this vision.
Enabling the Effective Involvement of Multiple Users: Methods and Tools for Collaborative Software Engineering
Authors: Douglas L. Dean, James Lee, Mark Pendergast, Ann M. Hickey, Jay F. Nunamaker
Published in: Journal of Management Information Systems (1997-12-01)

:The paper presents results of ongoing research to support effective user involvement during systems development projects. The Collaborative Software Engineering Methodology is presented as a framework that contains mechanisms to support three layers of user involvement: selected user representatives, user groups, and the broader user community. Productivity and user participation of traditional group meetings have been limited by chauffeured facilitation and by support of single-user tools designed for analysts rather than users. The paper introduces electronic meeting systems (EMS) modeling tools designed to allow users to work in parallel to contribute directly during meetings. These tools are easy to use while containing support features traditionally associated with CASE tools. The methodology includes a sequence of requirements abstractions that users engage directly including activity models, data models, scenarios, system use cases, and prototypes. This methodology is designed to help organizations respond to today’s rapidly changing information processing needs.
Requirements Elicitation in Software Engineering
Authors: Muhammad Ali Ramdhani, Dian Sa’adillah Maylawati, Abdusy Syakur Amin, Hilmi Aulawi
Published in: International Journal of Engineering & Technology (2018-05-22)

Software Engineering (SE) is a discipline, concept, method that focus on all aspects related to software production. SE must adapt organized system and approach in building software. The objective of this article is to discuss needs elicitation in SE, so that the design can be done through utilizing appropriate tools and techniques based on the problem to be solved, restrictions and need that must be met, as well as resource availability. The method used in this article is literature review as a major source of problem analysis. In the next phase, the main topic of the article is clarified, validated, and verified by the model of the Focus Group Discussion (FGD). The respondents of FGD are lecturers of Informatics Department at UIN Sunan Gunung Djati Bandung. Requirements elicitation is in-dept and comprehensive process of finding information from all stakeholders in relation to the built software. The result of requirements elicitation is the explanation from every stakeholder with natural language related to the will and interest of the built software. The mechanism of finding information can be done through observation, questionnaire, interview, and documentary study, which are then tested with data validation and verification in FGD. The product of requirements elicitation is the User Requirement Document (URD) that can be used as an early artifact in software development process. Furthermore, URD is used as a reference in tracking the suitability between the function of software and the needs of stakeholder. This article formulated analysis approach of SE need, so that it is easily modified, adaptive to growing software complexity, and connected with the analysis of hardware.
Software engineering
Authors: Nancy G. Leveson
Published in: Communications of the ACM (1997-02-01)

article Free AccessSoftware engineering: stretching the limits of complexity Author: Nancy G. Leveson Univ. of Washington, Seattle Univ. of Washington, SeattleView Profile Authors Info & Claims Communications of the ACMVolume 40Issue 201 February 1997pp 129–131https://doi.org/10.1145/253671.253754Published:01 February 1997Publication History 22citation628DownloadsMetricsTotal Citations22Total Downloads628Last 12 Months35Last 6 weeks2 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF