# Software Engineering

Software engineering is the systematic application of engineering principles to the design, development, testing, maintenance, and retirement of software systems.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Ontology of Software Maintenance

DevFeed: [Ontology of Software Maintenance](<https://devfeed.tech/articles/ontology-of-software-maintenance-145774.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.25196>)

Author: Luis Olsina, Pablo Becker, Maria Fernanda Papa

Published: 2026-11-20T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [Software Process](<https://devfeed.tech/topics/software-process.md>)

Tags: [analysis](<https://devfeed.tech/tags/analysis.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [artifacts](<https://devfeed.tech/tags/artifacts.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [defect](<https://devfeed.tech/tags/defect.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [enhancement](<https://devfeed.tech/tags/enhancement.md>), [functionality](<https://devfeed.tech/tags/functionality.md>), [improvement](<https://devfeed.tech/tags/improvement.md>), [maintenance](<https://devfeed.tech/tags/maintenance.md>), [model](<https://devfeed.tech/tags/model.md>), [ontology](<https://devfeed.tech/tags/ontology.md>), [processes](<https://devfeed.tech/tags/processes.md>), [resources](<https://devfeed.tech/tags/resources.md>), [roles](<https://devfeed.tech/tags/roles.md>), [software](<https://devfeed.tech/tags/software.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>), [software-maintenance](<https://devfeed.tech/tags/software-maintenance.md>), [specification](<https://devfeed.tech/tags/specification.md>), [strategy](<https://devfeed.tech/tags/strategy.md>), [target](<https://devfeed.tech/tags/target.md>)

### AI overview

The Software Maintenance Top-Domain Ontology (SwMaintTDO) aims to reduce terminology inconsistencies in software maintenance by providing a unified, extensible model. Developed within a five-tier architecture, it draws on competency questions, analysis of documented maintenance processes, artifacts and resources, and alignment with software engineering standards. Its concepts cover maintenance processes, roles, resources, artifacts, goals, and changes from current to updated situations for modifiable and context entities. The abstract demonstrates its use in specifying a corrective maintenance strategy; it does not provide further evidence about evaluation or outcomes.

### Source excerpt

arXiv:2611.25196v1 Announce Type: new Abstract: Software maintenance is often a long and costly phase of the software lifecycle, encompassing activities such as defect correction, adaptation, code improvement, and functionality enhancement. Conceptual inconsistencies and terminological variation continue to hinder effective communication among researchers and practitioners. To address this gap, this paper presents the Software Maintenance Top-Domain Ontology (SwMaintTDO), a high-domain ontology developed within a five-tier ontological architecture. This ontology was constructed using competency questions, ontological analysis of documented maintenance processes, artifacts, and resources, and alignment with established software engineering standards. SwMaintTDO provides a unified and extensible conceptual model for representing key maintenance processes, roles, resources, artifacts, goal purposes, and the transition of target modifiable and context entities from current to updated maintenance situations. The applicability and value of SwMaintTDO are demonstrated through its application -via its concepts and relationships- to the process specification of a corrective maintenance strategy.

## My Least Favorite Example in Software Engineering

DevFeed: [My Least Favorite Example in Software Engineering](<https://devfeed.tech/articles/my-least-favorite-example-in-software-engineering-144363.md>)

Original publisher: [Read original article](<https://buttondown.com/hillelwayne/archive/my-least-favorite-example-in-software-engineering/>)

Author: Hillel Wayne

Published: 2026-11-19T15:40:32Z

Content type: opinion

Language: en

Sources: [Newsletter feed for Hillel Wayne's Newsletter](<https://devfeed.tech/sources/newsletter-feed-for-hillel-wayne-s-newsletter.md>)

Topics: [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [Fuzzing/Fuzz testing](<https://devfeed.tech/topics/fuzzing.md>), [Learning](<https://devfeed.tech/topics/learning.md>)

Tags: [example](<https://devfeed.tech/tags/example.md>), [property-based-testing](<https://devfeed.tech/tags/property-based-testing.md>), [reverse](<https://devfeed.tech/tags/reverse.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

The familiar property-based testing example--generating a random list and checking that reversing it twice restores the list--shows what PBT is, but the author says it poorly teaches why the technique matters in real software. Examples should be understandable, representative of real use, and help learners find related cases. The author suggests the example spread because it is simple and language-agnostic, and because John Hughes's QuickCheck paper used it. Earlier authors, including Zohar Manna, Boyer and Moore, and Richard Bird and Philip Wadler, had used double reversal to illustrate proofs; Hughes used it as a property to test. The same example can suit one context and fail another, and double reversal was useful in Hughes's work on list representations. The critique is about teaching usefulness, not blame.

### Source excerpt

I'm doing a lightning talk at Brooklyn Web Workers on 11/30! If you're in the area, come check it out. If you're not in the area (like 99.90% of the world), you can just read this newsletter instead. As you probably know, I am obsessed with examples. Really, really, really obsessed with examples. The best examples should at least: Be simple enough to understand Clearly showcase the topic under discussion Actually correspond to how the topic manifests in the real world Give some rough idea on how to find other examples in the same vein Basically, the example needs to both help the student understand the topic and also why the topic matters. If not to them, at least to someone they know. A good example of a good example is demonstrating type safety with option types, which ensure that you always handle nulls in your program. It's intuitive, clear, and simple, and it shows why and how this would be useful in practice. But I'm not here to talk about good examples. I'm here to talk about bad examples Specifically my least favorite example. Property-Based Testing is a testing approach where we generate random inputs to a program and check the outputs all satisfy some property. And like half the PBT introductions online use this same example: test reverse-reverse: l = random_list() reverse(reverse(l)) == l I hate this example because 1) I see it every-freakin'-where, and 2) it fails the "this topic matters" criteria hard. It gives you some idea of what property-based testing is, but doesn't give you any way to relate it to actual real-world testing. I mean, who writes list reversal algorithms for their job?1 And sure, common examples of regular testing like add(1, 2) == 3 are also useless, but 1) regular testing is mundane and you can probably figure out more useful tests from that 2) most people can give you better examples than that! PBT, on the other hand, is quite exotic for most people and they need a lot of guidance on how to go from "learning about the concept of pr

## College Board Delivers Another AI Ultimatum: No AI, No AP CS Principles Course

DevFeed: [College Board Delivers Another AI Ultimatum: No AI, No AP CS Principles Course](<https://devfeed.tech/articles/college-board-delivers-another-ai-ultimatum-no-ai-no-ap-cs-principles-course-142916.md>)

Original publisher: [Read original article](<https://news.slashdot.org/story/26/11/19/0628241/college-board-delivers-another-ai-ultimatum-no-ai-no-ap-cs-principles-course>)

Author: BeauHD

Published: 2026-11-19T11:00:00Z

Content type: news

Language: en

Sources: [Slashdot](<https://devfeed.tech/sources/slashdot.md>)

Topics: [Learning](<https://devfeed.tech/topics/learning.md>), [AI Engineering](<https://devfeed.tech/topics/ai-engineering.md>), [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [Programming Languages / Compilers](<https://devfeed.tech/topics/programming-languages-compilers.md>), [Blockly](<https://devfeed.tech/topics/blockly.md>)

Tags: [2027](<https://devfeed.tech/tags/2027.md>), [about](<https://devfeed.tech/tags/about.md>), [after](<https://devfeed.tech/tags/after.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-application](<https://devfeed.tech/tags/ai-application.md>), [ai-powered](<https://devfeed.tech/tags/ai-powered.md>), [ai-tool](<https://devfeed.tech/tags/ai-tool.md>), [also](<https://devfeed.tech/tags/also.md>), [app](<https://devfeed.tech/tags/app.md>), [application](<https://devfeed.tech/tags/application.md>), [ban](<https://devfeed.tech/tags/ban.md>), [based](<https://devfeed.tech/tags/based.md>), [block](<https://devfeed.tech/tags/block.md>), [blockly](<https://devfeed.tech/tags/blockly.md>), [board](<https://devfeed.tech/tags/board.md>), [build](<https://devfeed.tech/tags/build.md>), [build-with-ai](<https://devfeed.tech/tags/build-with-ai.md>), [college](<https://devfeed.tech/tags/college.md>), [course](<https://devfeed.tech/tags/course.md>), [education](<https://devfeed.tech/tags/education.md>), [principles](<https://devfeed.tech/tags/principles.md>)

### AI overview

The College Board plans to redesign AP Computer Science Principles starting in fall 2027 around responsible AI use. Students will learn to use AI to design, debug, and evaluate code, assess when it is wrong, and build an AI application for an AI Create Project; the exam will include free-response questions about that project. Schools must provide each student with access to a district-approved AI tool that accepts written instructions and returns a response. Starting in 2028-29, project submissions must use one of a limited number of text-based languages. Teachers may continue using block-based tools for instruction, but students must learn an approved text-based language before submitting. The excerpt does not specify the approved tools or languages.

### Source excerpt

Longtime Slashdot reader theodp writes: Just days after news broke of Google's no AI, no Search ultimatum -- prompting school districts to weigh breaking up with Google Search (source paywalled; alternative source) -- the College Board quietly delivered another AI ultimatum to the nation's AP Computer Science Principles teachers, suggesting that their days of teaching AP CSP might be over unless their school districts put an end to their anti-AI ways. "Effective in fall 2027," The College Board explained, "AP Computer Science Principles has been reimagined as the course for teaching students how to work with AI responsibly, safely, and confidently. AI is integral to the world of computer science. Software engineering remains one of the largest professional job categories, and employers now expect software engineers to be fluent in AI. What sets candidates apart is a deeper understanding of AI for designing, debugging, and evaluating code, and the ability to determine when AI is wrong. The redesigned course develops these skills, empowering students to build with AI, not just learn about it. [...] Students also complete an AI Create Project, in which they build an AI application. The AP Exam includes free-response questions about the project, so students who earn a qualifying score for college credit have demonstrated their ability to design, build, and understand an AI-powered application. [...] Students need access to a district-approved AI tool that accepts a student's own written instructions and returns a response. Schools will need to make sure every student has access to one." The College Board also announced a planned ban on the use of block-based programming languages like Snap!, Scratch, Blockly, and MIT App Inventor for students' "AI Create Project" (which replaces the current "Create Performance Task" that counts for 30% of a student's AP exam score): "Beginning with the 2028-29 school year, students will submit their AI Create Project in one of a limited

## What AI-First Engineering Means for the Future of Software Quality

DevFeed: [What AI-First Engineering Means for the Future of Software Quality](<https://devfeed.tech/articles/what-ai-first-engineering-means-for-the-future-of-software-quality-145967.md>)

Original publisher: [Read original article](<https://testgrid.io/blog/ai-first-engineering/>)

Author: Ankita Nandi

Published: 2026-11-19T10:55:22Z

Content type: article

Language: en

Sources: [TestGrid](<https://devfeed.tech/sources/testgrid-blog.md>)

Topics: [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>), [mutation-testing](<https://devfeed.tech/topics/mutation-testing.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>), [business logic](<https://devfeed.tech/topics/business-logic.md>), [engineering-leadership](<https://devfeed.tech/topics/engineering-leadership.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agent](<https://devfeed.tech/tags/ai-agent.md>), [ai-generated-tests](<https://devfeed.tech/tags/ai-generated-tests.md>), [ai-testing](<https://devfeed.tech/tags/ai-testing.md>), [ai-workflow](<https://devfeed.tech/tags/ai-workflow.md>), [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [automation](<https://devfeed.tech/tags/automation.md>), [bank](<https://devfeed.tech/tags/bank.md>), [behavior](<https://devfeed.tech/tags/behavior.md>), [billing](<https://devfeed.tech/tags/billing.md>), [block](<https://devfeed.tech/tags/block.md>), [browser](<https://devfeed.tech/tags/browser.md>), [browsers](<https://devfeed.tech/tags/browsers.md>), [credit-card](<https://devfeed.tech/tags/credit-card.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [quality](<https://devfeed.tech/tags/quality.md>), [rules](<https://devfeed.tech/tags/rules.md>), [software](<https://devfeed.tech/tags/software.md>), [system](<https://devfeed.tech/tags/system.md>), [tests](<https://devfeed.tech/tags/tests.md>)

### AI overview

AI-first workflows can accelerate software delivery, but when an agent derives code, tests and documentation from the same incomplete requirement, they can all reinforce one mistaken assumption. The excerpt distinguishes tests that confirm behavior inferred from buggy code from tests that correctly enforce a flawed or underspecified business rule; either can leave a green build that fails users. It recommends agreeing on expected behavior and edge-case examples before implementation, having an accountable domain expert approve them, and generating business-rule tests from those approved expectations. Validate AI-generated tests by planting known bugs. For high-risk changes, add independent security review, hands-on human testing and sign-off. Use execution evidence such as video, screenshots, logs and network traffic to investigate failures, and measure customer bugs, pre-release risks and diagnosis time rather than test counts alone. The excerpt also calls for junior engineers to practice questioning requirements and explaining conclusions. Its example is hypothetical, and the overview reflects the supplied excerpt.

### Source excerpt

Let's say you oversee a bank's credit-card billing-error system. Your product team gives an AI agent a requirement: "Accept written billing-error notices within 60 days." The agent implements the rule, generates 40 tests, and reports that every test passes. But it has started the clock on the transaction date. Under US federal billing-error rules, the [...]

## Exploring multimodal AI--XR interactions for software development: From expert perspectives to semantic code outlines

DevFeed: [Exploring multimodal AI--XR interactions for software development: From expert perspectives to semantic code outlines](<https://devfeed.tech/articles/exploring-multimodal-ai-xr-interactions-for-software-development-from-expert-perspectives-to-semantic-code-outlines-142211.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.24334>)

Author: Ilya Zakharov, Alexey Markin, Konstantin Ostroukhov, Alexey Perminov, Roham Koohestani, Ekaterina Koshchenko, Agnia Sergeyuk

Published: 2026-11-19T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [human computer interaction](<https://devfeed.tech/topics/human-computer-interaction.md>), [User interface design](<https://devfeed.tech/topics/ui-design.md>), [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [AI tools for developers](<https://devfeed.tech/topics/ai-tools-for-developers.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [attention](<https://devfeed.tech/tags/attention.md>), [code](<https://devfeed.tech/tags/code.md>), [cs-hc](<https://devfeed.tech/tags/cs-hc.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [development](<https://devfeed.tech/tags/development.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [experts](<https://devfeed.tech/tags/experts.md>), [extended-reality](<https://devfeed.tech/tags/extended-reality.md>), [headset](<https://devfeed.tech/tags/headset.md>), [ide](<https://devfeed.tech/tags/ide.md>), [input](<https://devfeed.tech/tags/input.md>), [inspection](<https://devfeed.tech/tags/inspection.md>), [multimodal](<https://devfeed.tech/tags/multimodal.md>), [multimodal-ai](<https://devfeed.tech/tags/multimodal-ai.md>), [navigation](<https://devfeed.tech/tags/navigation.md>), [original](<https://devfeed.tech/tags/original.md>), [overview](<https://devfeed.tech/tags/overview.md>), [prototype](<https://devfeed.tech/tags/prototype.md>), [software](<https://devfeed.tech/tags/software.md>), [software-development](<https://devfeed.tech/tags/software-development.md>), [xr](<https://devfeed.tech/tags/xr.md>)

### AI overview

The exploratory study examined whether XR context could help developers manage AI-generated code that still needs understanding and verification. Researchers interviewed 13 experts, then had 12 professional developers try two prototypes: one made viewed code fade away; the other replaced viewed sections with brief purpose descriptions. In the latter, head direction helped trigger an offer, while developers used manual input to apply it or reopen the original code. Seven software-engineering researchers also provided feedback in an open-ended demonstration. Participants said descriptions could orient them to unfamiliar code and act as reminders, but comparing descriptions with source code, headset limitations, and controls unlike familiar IDE routines could add effort. The findings call for summaries that are easy to find, direct access to original code, and familiar navigation and editing practices. These are exploratory findings, not evidence of comparative effectiveness.

### Source excerpt

arXiv:2611.24334v1 Announce Type: cross Abstract: AI tools can generate code quickly, but developers still need to understand and check the results. We explore how the enriched multimodal context derived from the extended reality (XR) workspace might help developers manage this information. We first interviewed 13 experts in AI, XR, and related fields to identify opportunities and design challenges (Study 1). These interviews informed two prototypes explored with 12 professional developers (Study 2): four tried a version where the code faded to become invisible after it was looked at, and eight tried a version that replaced viewed code sections with short descriptions of their purpose. In the second prototype, head direction helped determine when to offer a change, while manual input let developers apply it and reopen the original code. A separate open-ended demonstration with seven software-engineering researchers provided complementary feedback. Participants' accounts suggested that descriptions could provide an overview of unfamiliar code and serve as reminders when revisiting it. However, difficulty comparing descriptions with source code, headset limitations, and controls that deviates from regular IDE routines could introduce additional effort. These exploratory findings identify requirements for attention support: make summaries easy to recognize and access, preserve straightforward inspection of the original code, and retain familiar navigation and editing practices. The study contributes to human-centered multimodal systems by showing how the coordination of input channels and AI-generated representations must account for users' attention, verification needs, and established ways of working.

## Controlled Natural Language for Requirements Specification: A Systematic Literature Review

DevFeed: [Controlled Natural Language for Requirements Specification: A Systematic Literature Review](<https://devfeed.tech/articles/controlled-natural-language-for-requirements-specification-a-systematic-literature-review-142136.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.23259>)

Author: Ikram Darif (Department of Software and IT Engineering, Ecole de technologie superieure, Montreal, Canada), Ghizlane El Boussaidi (Department of Software and IT Engineering, Ecole de technologie super

Published: 2026-11-19T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Requirements](<https://devfeed.tech/topics/requirements.md>), [Specifications](<https://devfeed.tech/topics/specifications.md>), [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>)

Tags: [cs-se](<https://devfeed.tech/tags/cs-se.md>), [language](<https://devfeed.tech/tags/language.md>), [literature](<https://devfeed.tech/tags/literature.md>), [natural-language](<https://devfeed.tech/tags/natural-language.md>), [requirements](<https://devfeed.tech/tags/requirements.md>), [review](<https://devfeed.tech/tags/review.md>), [specification](<https://devfeed.tech/tags/specification.md>)

### AI overview

The review analyzes 133 studies published from 2000 to 2024 on controlled natural languages (CNLs) for specifying software requirements. It categorizes approaches into standalone templates, requirement patterns, elementary templates, and linguistic rules, and compares them across context, scope, requirement types, specification technique, tool support, validation, and adoption. The authors report limited automated tool support and domain vocabulary use, few case-study validations, and limited adoption for most approaches. CNLs aim to make requirements both understandable to stakeholders and precise enough for automated processing, bridging natural and formal languages.

### Source excerpt

arXiv:2611.23259v1 Announce Type: new Abstract: Requirements are critical artifacts of the software development life-cycle. They express capabilities that the system should provide, guiding both the development and testing process. Given their significance, require- ments specification has attracted the interest of researchers and practitioners in recent years. Requirements specification is an activity where requirements are specified, i.e., documented. In this context, Controlled Natural Languages (CNL) were proposed as a compromise between the ambiguity of natural language and the complexity of formal languages. CNLs enable the specification of requirements using accurate statements that can be processed automatically, while remaining understandable by stakeholders. In this article, we perform a Systematic Literature Review (SLR) to identify, categorize, and compare CNL approaches for requirements specification. The SLR covers 133 primary studies published between 2000 and 2024. We evaluate them accord- ing to seven dimensions: context, scope, targeted requirements types, specification technique, tool support, validation method, and adoption. We provide a categorization framework that summarizes the evaluated dimensions, and we identify directions for future research. Our main results reveal: (1) four types of CNL: standalone templates, requirement patterns, elementary templates, and linguistic rules, (2) limited support for automated tools and domain vocabulary usage, and (3) lack of validation through case studies and limited adoption for the majority of approaches.

## An Industry Perspective on Software Vulnerability Management: A Systematic Review of Approaches, Tools, Practices, and Challenges

DevFeed: [An Industry Perspective on Software Vulnerability Management: A Systematic Review of Approaches, Tools, Practices, and Challenges](<https://devfeed.tech/articles/an-industry-perspective-on-software-vulnerability-management-a-systematic-review-of-approaches-tools-practices-and-challenges-142142.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.23267>)

Author: M. Mehdi Kholoosi, Triet Huynh Minh Le, M. Ali Babar

Published: 2026-11-19T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>), [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [software security audit](<https://devfeed.tech/topics/software-security-audit.md>), [Software Process](<https://devfeed.tech/topics/software-process.md>), [Tool](<https://devfeed.tech/topics/tool.md>)

Tags: [challenges](<https://devfeed.tech/tags/challenges.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [industry](<https://devfeed.tech/tags/industry.md>), [management](<https://devfeed.tech/tags/management.md>), [practices](<https://devfeed.tech/tags/practices.md>), [review](<https://devfeed.tech/tags/review.md>), [software](<https://devfeed.tech/tags/software.md>), [software-vulnerability](<https://devfeed.tech/tags/software-vulnerability.md>), [tools](<https://devfeed.tech/tags/tools.md>), [vulnerability-management](<https://devfeed.tech/tags/vulnerability-management.md>)

### AI overview

A review of 57 industry-practitioner studies published from 2010 to 2025 finds that software vulnerability management research is weighted toward practice guidance and vulnerability detection and repair; fewer studies evaluate concrete tools or approaches in industry, and assessment and disclosure receive less practitioner-centred coverage. Practitioners report persistent organisational barriers: limited security expertise and time, unclear responsibility, poorly coordinated processes, and tools that are hard to understand, configure, or integrate into workflows. The authors call for integrated socio-technical interventions and evaluations that assess lasting workflow impact alongside technical performance.

### Source excerpt

arXiv:2611.23267v1 Announce Type: new Abstract: Software vulnerability management (SVM) refers to coordinated activities to detect, assess, repair, and disclose software vulnerabilities (SVs) across a product or ecosystem. As software systems grow in scale and dependency depth, organisations must balance timely security action with limited expertise, evolving tooling, and delivery pressure. In this practitioner-centred systematic literature review, we synthesise 57 peer-reviewed empirical studies published between 2010 and 2025 that collect primary data directly from industry practitioners. We examine the SVM solutions (approaches, tools, and practices) proposed and evaluated with practitioners and the challenges practitioners report when adopting and using these solutions in real-world settings. We find that practice-oriented contributions, such as guidelines, recommendations, lessons learned, and shared experiences, constitute most of the evidence base, while fewer studies evaluate concrete approaches and tools in industrial environments. The solution landscape and evaluation focus are weighted toward SV detection and repair, with comparatively limited practitioner-centred coverage of SV assessment and disclosure. The most persistent challenges concern how SVM work is organised and embedded: limited security expertise and time, unclear responsibility for SV-related decisions, scattered or poorly coordinated processes, and tools that are difficult to understand, configure, or integrate into existing workflows. These findings highlight the need for more integrated socio-technical interventions, stronger coverage of under-studied SVM tasks, and evaluations that prioritise sustained workflow impact alongside technical performance.

## SWE-growth: Teacher-Guided Adaptive Self-Play for Software Engineering Agents

DevFeed: [SWE-growth: Teacher-Guided Adaptive Self-Play for Software Engineering Agents](<https://devfeed.tech/articles/swe-growth-teacher-guided-adaptive-self-play-for-software-engineering-agents-142200.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.23876>)

Author: Songshi Liang, Zixuan Huang, Mingxuan Song, Haoyu Tang, Shusheng Xu, Tongkai Yang, Zihe Wang, Rui Yan

Published: 2026-11-19T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Reinforcement learning](<https://devfeed.tech/topics/reinforcement-learning.md>), [Fine-tuning](<https://devfeed.tech/topics/fine-tuning.md>), [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [Enhancing AI model performance](<https://devfeed.tech/topics/enhancing-ai-model-performance.md>)

Tags: [adaptive](<https://devfeed.tech/tags/adaptive.md>), [agents](<https://devfeed.tech/tags/agents.md>), [capability](<https://devfeed.tech/tags/capability.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [growth](<https://devfeed.tech/tags/growth.md>), [play](<https://devfeed.tech/tags/play.md>), [qwen3](<https://devfeed.tech/tags/qwen3.md>), [qwen3-coder](<https://devfeed.tech/tags/qwen3-coder.md>), [reinforcement-learning](<https://devfeed.tech/tags/reinforcement-learning.md>), [repair](<https://devfeed.tech/tags/repair.md>), [repository](<https://devfeed.tech/tags/repository.md>), [selection](<https://devfeed.tech/tags/selection.md>), [sft](<https://devfeed.tech/tags/sft.md>), [software](<https://devfeed.tech/tags/software.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>), [supervised-fine-tuning](<https://devfeed.tech/tags/supervised-fine-tuning.md>), [swe-bench-pro](<https://devfeed.tech/tags/swe-bench-pro.md>), [tasks](<https://devfeed.tech/tags/tasks.md>), [training](<https://devfeed.tech/tags/training.md>)

### AI overview

SWE-Growth uses verified Teacher repairs to turn Student failures into training opportunities. Tasks the Student consistently fails but the Teacher reliably solves supply demonstrations for supervised fine-tuning; after fine-tuning, mixed-outcome tasks with a positive Teacher-Student success gap are selected for reinforcement learning. Task eligibility also guides updates to the task-generating Injector. Starting from 101 seed issues, the framework raised Qwen3-Coder-30B-A3B-Instruct from 27.7% to 31.7% on SWE-bench Pro and from 11.0% to 17.2% on held-out TerminalBench 2.1 by Round 2. Under approximately matched budgets, gains exceeded Student-only self-play by 2.6 and 4.1 percentage points, and Teacher-augmented self-play by 1.8 and 2.5 points, respectively.

### Source excerpt

arXiv:2611.23876v1 Announce Type: new Abstract: Self-play offers a scalable way to train software engineering agents by generating repository-level repair tasks. However, with binary repair rewards and finite rollout budgets, all-fail groups provide no reward-based group-relative advantage. Such tasks may still offer learning opportunities when a Teacher can provide verified repairs absent from the Student's own attempts. We introduce SWE-Growth, a teacher-guided adaptive self-play framework that uses verified Teacher outcomes to identify learning opportunities for the current Student. Tasks with all students failure but reliable Teacher success provide demonstrations for supervised fine-tuning (SFT), and post-SFT Student rollouts identify mixed-outcome tasks with a positive Teacher--Student gap for reinforcement learning. Task eligibility also guides Injector updates, connecting Student training with subsequent task generation. Starting from 101 seed issues, \textsc{SWE-Growth} improves Qwen3-Coder-30B-A3B-Instruct from 27.7% to 31.7% on SWE-bench Pro and from 11.0% to 17.2% on held-out TerminalBench 2.1 by Round~2. It exceeds Student-only self-play by 2.6 and 4.1 percentage points, respectively, and Teacher-augmented self-play by 1.8 and 2.5 points under approximately matched budgets. These results support adapting both supervision and task selection to the Student's evolving repair capability.

## Systematic Mapping Protocol. Generative AI-Augmented Requirements Engineering: A Systematic Mapping Study of Practices, Specifications, and Reuse in Software Development

DevFeed: [Systematic Mapping Protocol. Generative AI-Augmented Requirements Engineering: A Systematic Mapping Study of Practices, Specifications, and Reuse in Software Development](<https://devfeed.tech/articles/systematic-mapping-protocol-generative-ai-augmented-requirements-engineering-a-systematic-mapping-study-of-practices-specifications-and-reuse-in-software-development-142182.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.23349>)

Author: Fernando Pinciroli

Published: 2026-11-19T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>), [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Requirements](<https://devfeed.tech/topics/requirements.md>), [Generative AI](<https://devfeed.tech/topics/generative-ai.md>), [Spec Driven Development](<https://devfeed.tech/topics/spec-driven-development.md>), [Specifications](<https://devfeed.tech/topics/specifications.md>), [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>)

Tags: [classification](<https://devfeed.tech/tags/classification.md>), [code-generation](<https://devfeed.tech/tags/code-generation.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [data-extraction](<https://devfeed.tech/tags/data-extraction.md>), [generative-ai](<https://devfeed.tech/tags/generative-ai.md>), [large-language-models-llms](<https://devfeed.tech/tags/large-language-models-llms.md>), [mapping](<https://devfeed.tech/tags/mapping.md>), [prompting](<https://devfeed.tech/tags/prompting.md>), [protocol](<https://devfeed.tech/tags/protocol.md>), [requirements-engineering](<https://devfeed.tech/tags/requirements-engineering.md>), [reuse](<https://devfeed.tech/tags/reuse.md>), [specifications](<https://devfeed.tech/tags/specifications.md>), [threats](<https://devfeed.tech/tags/threats.md>), [transparency](<https://devfeed.tech/tags/transparency.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

The document sets out a protocol for a systematic mapping study of generative AI in requirements engineering, focusing on the specifications it produces and how those work products are used downstream. It asks how they support activities such as specification-driven development, design and code generation, test derivation, verification, and reuse. The protocol specifies research questions and classification schemes, search and study selection procedures, data extraction and analysis, tool support, and threats to validity. Published in advance, it aims to establish prior commitment and make the planned study transparent and repeatable; it reports a protocol, not mapping results.

### Source excerpt

arXiv:2611.23349v1 Announce Type: new Abstract: Generative artificial intelligence (GenAI), particularly large language models (LLMs), is rapidly being adopted in requirements engineering (RE). Existing secondary studies have characterized which RE activities are supported and which prompting strategies are used, but little is known about the specifications that GenAI-augmented RE produces and how they are used in subsequent activities such as specification-driven development (SDD), design and code generation, test derivation, verification, and reuse. This document presents the protocol of a systematic mapping study (SMS) that will identify and classify research on GenAI-augmented RE, with particular attention to the work products it generates and their downstream use. The protocol defines the research questions and their classification schemes, the search strategy, the study selection procedure, the data extraction form, the analysis approach, the tool support, and the threats to validity. It is published in advance to establish a prior commitment and to support the transparency and repeatability of the study.

## From Data Quality to Data Trustworthiness in AI-Driven Software-Intensive Embedded Systems: A Systematic Review

DevFeed: [From Data Quality to Data Trustworthiness in AI-Driven Software-Intensive Embedded Systems: A Systematic Review](<https://devfeed.tech/articles/from-data-quality-to-data-trustworthiness-in-ai-driven-software-intensive-embedded-systems-a-systematic-review-142129.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.23252>)

Author: Hariharan Gopinath, Jan Bosch, Helena Holmstr\\"om Olsson

Published: 2026-11-19T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>), [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Embedded Systems](<https://devfeed.tech/topics/embedded-systems.md>), [AI-Ready Data](<https://devfeed.tech/topics/ai-ready-data.md>), [Machine learning](<https://devfeed.tech/topics/machine-learning.md>), [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [ai evaluation](<https://devfeed.tech/topics/ai-evaluation.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [assessment](<https://devfeed.tech/tags/assessment.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [data](<https://devfeed.tech/tags/data.md>), [data-quality](<https://devfeed.tech/tags/data-quality.md>), [embedded-systems](<https://devfeed.tech/tags/embedded-systems.md>), [lifecycle](<https://devfeed.tech/tags/lifecycle.md>), [model](<https://devfeed.tech/tags/model.md>), [monitoring](<https://devfeed.tech/tags/monitoring.md>), [review](<https://devfeed.tech/tags/review.md>), [runtime-monitoring](<https://devfeed.tech/tags/runtime-monitoring.md>), [software](<https://devfeed.tech/tags/software.md>), [training](<https://devfeed.tech/tags/training.md>), [upstream](<https://devfeed.tech/tags/upstream.md>)

### AI overview

A systematic review of 27 studies published from January 2020 to February 2026 finds that data quality problems can weaken data trustworthiness in AI-driven software-intensive embedded systems (SIES), with effects reported on model or decision performance. It groups 16 concerns into Source Quality and Content Quality and identifies eight assessment and management method categories. Runtime monitoring is the largest category, but upstream and training-time controls are poorly integrated with runtime assurance; no reviewed study covers the full lifecycle. The synthesis suggests early data source or handling problems may persist in training baselines and be hard to detect during operation. Data trustworthiness contributes to reliable SIES decisions but is only one component of AI-system trustworthiness.

### Source excerpt

arXiv:2611.23252v1 Announce Type: new Abstract: AI-driven software-intensive embedded systems (SIES) depend on data during development and operation. Poor data quality (DQ) may weaken data trustworthiness, yet evidence about its effects and lifecycle management remains fragmented. This systematic literature review synthesizes 27 primary studies published from January 2020 to February 2026. It examines DQ concerns and evidence linking them to reduced data trustworthiness, along with assessment and management methods. The review identifies 16 concerns organized as Source Quality and Content Quality. Studies provide DQ-based scores and evidence of effects on model or decision performance. Synthesis suggests upstream source or handling problems may become embedded in training baselines and remain difficult to detect at runtime. Eight method categories were identified. Runtime monitoring is the largest category, while upstream and training-time controls remain poorly integrated with runtime assurance. No study covers the full lifecycle. Data trustworthiness supports reliable SIES decisions but is one component of AI-system trustworthiness.

## Escaping the Anthropomorphic Trap: Resolving the Cognitive Mismatch in Future AI Software Development

DevFeed: [Escaping the Anthropomorphic Trap: Resolving the Cognitive Mismatch in Future AI Software Development](<https://devfeed.tech/articles/escaping-the-anthropomorphic-trap-resolving-the-cognitive-mismatch-in-future-ai-software-development-142140.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.23264>)

Author: Yi Wang, Zheng Jiang, Gaowei Zhang, Min Zhang, Yang Feng

Published: 2026-11-19T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [AI Engineering](<https://devfeed.tech/topics/ai-engineering.md>), [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [Tech Debt](<https://devfeed.tech/topics/tech-debt.md>), [Multi Agent Systems](<https://devfeed.tech/topics/multi-agent-systems.md>), [ai-governance](<https://devfeed.tech/topics/ai-governance.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-software](<https://devfeed.tech/tags/ai-software.md>), [ai-software-development](<https://devfeed.tech/tags/ai-software-development.md>), [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [autonomous](<https://devfeed.tech/tags/autonomous.md>), [autonomous-agents](<https://devfeed.tech/tags/autonomous-agents.md>), [behavior](<https://devfeed.tech/tags/behavior.md>), [blueprint](<https://devfeed.tech/tags/blueprint.md>), [build](<https://devfeed.tech/tags/build.md>), [bypass](<https://devfeed.tech/tags/bypass.md>), [code](<https://devfeed.tech/tags/code.md>), [computational-topology](<https://devfeed.tech/tags/computational-topology.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [developers](<https://devfeed.tech/tags/developers.md>), [development](<https://devfeed.tech/tags/development.md>), [emulation](<https://devfeed.tech/tags/emulation.md>), [future](<https://devfeed.tech/tags/future.md>), [software](<https://devfeed.tech/tags/software.md>), [software-development](<https://devfeed.tech/tags/software-development.md>)

### AI overview

The paper argues that software practices designed around human working-memory limits can constrain multi-agent AI, whose reasoning is described as high-dimensional and stateless. It proposes Invisible Software Engineering (Invisible SE), which shifts governance from making agents emulate human workflows to shaping the repository as an active environment. The proposed environment uses topological gradients, temporally weighted memory, and representation-space regularization to guide agent behavior without classical code-level constraints. The abstract presents this as a potential blueprint for coordinating scalable, long-lived software infrastructures; it does not provide evidence of implementation or evaluation.

### Source excerpt

arXiv:2611.23264v1 Announce Type: new Abstract: For more than a half-century, the foundational paradigms of software development-such as modularity, information hiding, and hierarchical labor division-have been engineered to accommodate the strict cognitive limitations of human working memory. However, the rapid emergence of multi-agent artificial intelligence exposes a fundamental cognitive mismatch. Current frameworks attempt to integrate high-dimensional, stateless neural reasoning engines by coercing them to operate within these legacy, human-centric structures, falling into an anthropomorphic trap. This friction generates a novel, highly volatile behavioral entropy defined as AI-software technical debt, wherein amnesic agents hallucinate opaque workarounds to bypass architectural blindfolds. To resolve this, we propose Invisible Software Engineering (Invisible SE), a paradigm shift from agent-centric human emulation to environment-centric stigmergic governance. By reimagining the repository as an active computational topology which utilizes topological gradients, temporally weighted memory, and representation-space regularization, Invisible SE safely guides AI behavior without classical code-level constraints, thus transcending the cognitive horizons of human developers. This environment-centric protocol offers a potential blueprint for orchestrating scalable, long-lived computational infrastructures that transcend the cognitive horizons of human developers and enable autonomous agents to work, coordinate, and scale to build future software systems.

## Generative AI in Software Testing: Practitioners' Perspectives on the Benefits, Challenges, Opportunities, and Risks

DevFeed: [Generative AI in Software Testing: Practitioners' Perspectives on the Benefits, Challenges, Opportunities, and Risks](<https://devfeed.tech/articles/generative-ai-in-software-testing-practitioners-perspectives-on-the-benefits-challenges-opportunities-and-risks-142133.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.23256>)

Author: Chamari Dasanayake, Rahul Mohanani, Vladimir Mandi\\'c, Burak Turhan

Published: 2026-11-19T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>), [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Generative AI](<https://devfeed.tech/topics/generative-ai.md>), [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [challenges](<https://devfeed.tech/tags/challenges.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [generative](<https://devfeed.tech/tags/generative.md>), [generative-ai](<https://devfeed.tech/tags/generative-ai.md>), [perspectives](<https://devfeed.tech/tags/perspectives.md>), [risks](<https://devfeed.tech/tags/risks.md>), [software-testing](<https://devfeed.tech/tags/software-testing.md>)

### AI overview

A survey of 64 software testing practitioners found generally positive views of GenAI for reducing effort, generating tests, and debugging, alongside concerns about dependence on prompts, trust, and incorrect outputs. The study analyzed closed-ended responses descriptively and coded open-ended responses; 34 respondents had regular or experimental experience using GenAI for testing, while 30 had none. Users viewed several concrete benefits more positively and more often prioritized reliability risks; non-users were more uncertain about some technically specific challenges. The findings present GenAI as an assistive technology that requires human validation, and suggest that practitioners' experience matters when interpreting perceptions.

### Source excerpt

arXiv:2611.23256v1 Announce Type: new Abstract: Generative Artificial Intelligence (GenAI) increasingly supports software testing, yet empirical evidence on practitioners' perceptions remains limited. This study investigates perceived benefits, challenges, opportunities, and risks of GenAI in software testing through a questionnaire survey of 64 practitioners. Closed-ended responses were analyzed descriptively, while open-ended responses were qualitatively coded to contextualize the findings. Among the respondents, 34 were users (those with regular or experimental use of GenAI in testing) and 30 were non-users (those without prior use of GenAI in testing). Results show generally positive perceptions of GenAI for reducing effort, test generation, and debugging, alongside concerns about prompt dependence, trust, and incorrect outputs. Users were more positive about several concrete benefits while also more frequently prioritizing reliability-related risks, whereas non-users showed greater uncertainty about some technically specific challenges. Overall, the findings position GenAI as an assistive technology requiring human validation and highlight the importance of considering practitioners' experience with GenAI when interpreting perceptions of GenAI-assisted testing.

## The Comprehension Gap in LLM-Assisted Software Development: An Experiment

DevFeed: [The Comprehension Gap in LLM-Assisted Software Development: An Experiment](<https://devfeed.tech/articles/the-comprehension-gap-in-llm-assisted-software-development-an-experiment-142208.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.24216>)

Author: Julian Oertel, Jil Kl\\"under, Regina Hebig

Published: 2026-11-19T05:00:00Z

Content type: news

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>), [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [code-generation](<https://devfeed.tech/tags/code-generation.md>), [cognitive-debt](<https://devfeed.tech/tags/cognitive-debt.md>), [comparison](<https://devfeed.tech/tags/comparison.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [developer](<https://devfeed.tech/tags/developer.md>), [developers](<https://devfeed.tech/tags/developers.md>), [development](<https://devfeed.tech/tags/development.md>), [engagement](<https://devfeed.tech/tags/engagement.md>), [experiment](<https://devfeed.tech/tags/experiment.md>), [explore](<https://devfeed.tech/tags/explore.md>), [interviews](<https://devfeed.tech/tags/interviews.md>), [llm](<https://devfeed.tech/tags/llm.md>), [llm-assisted](<https://devfeed.tech/tags/llm-assisted.md>), [llm-tools](<https://devfeed.tech/tags/llm-tools.md>), [practices](<https://devfeed.tech/tags/practices.md>), [programming](<https://devfeed.tech/tags/programming.md>), [prompting](<https://devfeed.tech/tags/prompting.md>), [recordings](<https://devfeed.tech/tags/recordings.md>), [software](<https://devfeed.tech/tags/software.md>), [software-development](<https://devfeed.tech/tags/software-development.md>)

### AI overview

In a crossover experiment with 35 participants, LLM chat use shortened programming-task completion time, but participants understood their own code better on average: they completed code-comprehension tasks 20% faster and found 11% more mutations in self-written than generated code. Thirty-six percent reported better understanding of their self-written code. Comprehension declined significantly among participants with high reliance on the LLM and low task engagement. Interviews showed varied responses, including changing how they use LLMs or avoiding them. The authors call for further study of cognitive debt in larger systems and ways developers can address it.

### Source excerpt

arXiv:2611.24216v1 Announce Type: new Abstract: When LLM tools are pushed beyond their capabilities for software development tasks, developers must be able to step in. However, the comprehension that developers acquire during development might be negatively impacted due to excessive code generation. This could create a cognitive debt that needs to be resolved before tasks can be solved efficiently again. We explore how well developers understand code they generated by prompting in comparison to self-written and unseen code and how they reflect on their comprehension. We conduct a crossover experiment and interviews with 35 participants consisting of students, academic personnel, and software developers. After completing two programming tasks with or without LLM chat usage, respectively, participants are tasked with finding introduced mutations in the produced and additional unseen code. We use insights from interviews and screen recordings to supplement our results. Regarding the experiment, 36% of participants report a better understanding of self-written code compared to their generated code. On average, participants solved the comprehension task 20% faster for self-written code than for generated code and found 11% more mutations. Participants needed significantly less time to solve programming tasks when working with the LLM. However, participants with high reliance on the LLM chat and low task engagement showed significantly decreased comprehension. Our qualitative results show great variability in individual perspectives on comprehension differences and strategies to mitigate issues. Strategies for dealing with comprehension differences range from accepting comprehension differences to adapting their LLM interactions or avoiding the tools altogether. Our results warrant further investigation into cognitive debt in larger systems and developer practices to mitigate issues.

## Biomedical Knowledge Composition: A Software Engineering Perspective

DevFeed: [Biomedical Knowledge Composition: A Software Engineering Perspective](<https://devfeed.tech/articles/biomedical-knowledge-composition-a-software-engineering-perspective-142115.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2608.08927>)

Author: Natallia Kokash, Adam S. Z. Bellouma, Paola Grosso

Published: 2026-11-19T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [data-engineering](<https://devfeed.tech/topics/data-engineering.md>), [knowledge-engineering](<https://devfeed.tech/topics/knowledge-engineering.md>), [knowledge-management](<https://devfeed.tech/topics/knowledge-management.md>)

Tags: [biomedical](<https://devfeed.tech/tags/biomedical.md>), [challenges](<https://devfeed.tech/tags/challenges.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [data](<https://devfeed.tech/tags/data.md>), [data-integration](<https://devfeed.tech/tags/data-integration.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [development](<https://devfeed.tech/tags/development.md>), [digital-twins](<https://devfeed.tech/tags/digital-twins.md>), [discovery](<https://devfeed.tech/tags/discovery.md>), [drug-discovery](<https://devfeed.tech/tags/drug-discovery.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [entity-resolution](<https://devfeed.tech/tags/entity-resolution.md>), [governance](<https://devfeed.tech/tags/governance.md>), [graphs](<https://devfeed.tech/tags/graphs.md>), [knowledge-graphs](<https://devfeed.tech/tags/knowledge-graphs.md>), [package-management](<https://devfeed.tech/tags/package-management.md>), [perspectives](<https://devfeed.tech/tags/perspectives.md>), [pipelines](<https://devfeed.tech/tags/pipelines.md>), [practices](<https://devfeed.tech/tags/practices.md>), [software](<https://devfeed.tech/tags/software.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>)

### AI overview

The article argues that biomedical knowledge graphs are central to integrating molecular, clinical, and population data, but their construction is hindered by identifier mapping, entity resolution, schema alignment, evidence integration, and provenance tracking. It connects these domain challenges to limited adoption of mature software engineering practices, including package management, typed namespaces, canonical interchange formats, service composition, reproducible pipelines, and lifecycle governance. It catalogs eight open integration challenges, noting that partial solutions exist but no universally adopted stack. Its main emphasis is on reproducible KG assembly: reusable build pipelines and versioned dependencies that let others compile and customize graphs from source, rather than relying only on static deployed artifacts.

### Source excerpt

arXiv:2608.08927v2 Announce Type: replace Abstract: Biomedical research has accumulated vast molecular, clinical, and population data, yet translating this wealth into actionable knowledge remains constrained by technical and organizational difficulties. This article presents a unified treatment of two perspectives on biomedical knowledge infrastructure. The first introduces the biomedical domain to software engineers: it explains why knowledge graphs (KGs) are the central integrative data structure in modern biomedicine, characterizes five data harmonization challenges (identifier mapping, entity resolution, schema alignment, evidence integration, and provenance tracking), surveys application domains from drug discovery to digital twins, and profiles six representative KG systems with contrasting choices. The second perspective asks why engineering biomedical knowledge infrastructure remains so difficult. We argue that a contributing root cause is limited adoption of software tooling and practices that make development in other mature domains - particularly web engineering - reliably composable and reproducible: package management, typed namespaces, canonical interchange formats, service composition protocols, reproducible pipelines, and lifecycle governance. Against this backdrop, eight open engineering challenges for biomedical data integration are catalogued, each with partial solutions but no universally adopted stack. Crucially, the article shifts emphasis from describing deployed KG instances toward the reproducible process of assembling them: reusable build pipelines, versioned dependencies, and engineering practices that let others compile and customize a KG from source rather than consuming a static artifact. Together, the two perspectives provide domain grounding for newcomers and a research agenda for software engineers seeking to make transformative contributions to biomedical knowledge infrastructure.

## Structure-Behavior Coalescence for Model-Based Systems Engineering

DevFeed: [Structure-Behavior Coalescence for Model-Based Systems Engineering](<https://devfeed.tech/articles/structure-behavior-coalescence-for-model-based-systems-engineering-142132.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.23255>)

Author: William S. Chao

Published: 2026-11-19T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Model driven development](<https://devfeed.tech/topics/model-driven-development.md>), [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>)

Tags: [advanced](<https://devfeed.tech/tags/advanced.md>), [algebra](<https://devfeed.tech/tags/algebra.md>), [applications](<https://devfeed.tech/tags/applications.md>), [behavior](<https://devfeed.tech/tags/behavior.md>), [behaviors](<https://devfeed.tech/tags/behaviors.md>), [boundary](<https://devfeed.tech/tags/boundary.md>), [case-study](<https://devfeed.tech/tags/case-study.md>), [checkpoint](<https://devfeed.tech/tags/checkpoint.md>), [coherence](<https://devfeed.tech/tags/coherence.md>), [consistency](<https://devfeed.tech/tags/consistency.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [cs-sy](<https://devfeed.tech/tags/cs-sy.md>), [definition](<https://devfeed.tech/tags/definition.md>), [detection](<https://devfeed.tech/tags/detection.md>), [eess-sy](<https://devfeed.tech/tags/eess-sy.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [formal](<https://devfeed.tech/tags/formal.md>), [formal-verification](<https://devfeed.tech/tags/formal-verification.md>), [foundation](<https://devfeed.tech/tags/foundation.md>), [framework](<https://devfeed.tech/tags/framework.md>), [model](<https://devfeed.tech/tags/model.md>), [structure](<https://devfeed.tech/tags/structure.md>), [systems-engineering](<https://devfeed.tech/tags/systems-engineering.md>)

### AI overview

Structure-Behavior Coalescence (SBC) defines an MBSE system as one integrated entity, with structure and behavior joined through interaction. Its process-algebra framework imposes well-formedness constraints so interactions are grounded in structure and compositions remain valid. It uses 0 for terminal states and a checkpoint construct for paused or suspended states. The abstract says examples and a Smart Healthcare IoT case study demonstrate sequential, parallel, and alternative behaviors, and presents SBC as a basis for formal verification, compositional modeling, and inconsistency detection.

### Source excerpt

arXiv:2611.23255v1 Announce Type: new Abstract: Model-Based Systems Engineering (MBSE) has advanced system design and analysis for decades, yet traditional approaches often treat structure and behavior separately, resulting in inconsistencies, incomplete models, and ambiguity. This paper introduces Structure-Behavior Coalescence (SBC) as a formal and unified definition of systems for MBSE. SBC defines a system as a single integrated entity in which structure and behavior are coalesced through interaction, providing both a conceptual foundation and a formal process-algebra framework. Well-formedness constraints ensure that interactions are structurally grounded and compositions are valid, enabling consistency by construction. Boundary processes, including 0 for terminal states and a checkpoint construct for paused or suspended states, allow inactive and intermediate states to be represented while preserving system unity. Illustrative examples and a Smart Healthcare IoT case study demonstrate how SBC supports sequential, parallel, and alternative behaviors while maintaining structural-behavioral coherence. SBC provides a foundation for formal verification, compositional modeling, and systematic inconsistency detection, connecting a rigorous definition of systems with practical MBSE applications.

## Measuring What Matters in the Age of AI: The Research Software Metrics Landscape

DevFeed: [Measuring What Matters in the Age of AI: The Research Software Metrics Landscape](<https://devfeed.tech/articles/measuring-what-matters-in-the-age-of-ai-the-research-software-metrics-landscape-142130.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.23253>)

Author: Addi Malviya-Thakur, Reed Milewicz, Gregory R. Watson, Audris Mockus

Published: 2026-11-19T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>), [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>), [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [Maintainability](<https://devfeed.tech/topics/maintainability.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Code quality](<https://devfeed.tech/topics/code-quality.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-assisted-development](<https://devfeed.tech/tags/ai-assisted-development.md>), [attribution](<https://devfeed.tech/tags/attribution.md>), [automation](<https://devfeed.tech/tags/automation.md>), [capacity](<https://devfeed.tech/tags/capacity.md>), [challenges](<https://devfeed.tech/tags/challenges.md>), [code](<https://devfeed.tech/tags/code.md>), [community](<https://devfeed.tech/tags/community.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-ce](<https://devfeed.tech/tags/cs-ce.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [data](<https://devfeed.tech/tags/data.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [development](<https://devfeed.tech/tags/development.md>), [effort](<https://devfeed.tech/tags/effort.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [era](<https://devfeed.tech/tags/era.md>), [guidance](<https://devfeed.tech/tags/guidance.md>), [health](<https://devfeed.tech/tags/health.md>), [maintainability](<https://devfeed.tech/tags/maintainability.md>), [metrics](<https://devfeed.tech/tags/metrics.md>), [research](<https://devfeed.tech/tags/research.md>), [software](<https://devfeed.tech/tags/software.md>)

### AI overview

A focused synthesis of 49 substantive references groups research software metrics into eight families, assessed by data source, claimed construct, validity evidence, automation potential, and susceptibility to misuse. It finds that widely used metrics can be partial signals but are weak standalone measures of scientific impact. AI-assisted development sharpens gaps in provenance, generated-code maintainability, reviewer effort, dependencies, reuse and community-health signals, and credit for human work. The authors recommend contextual, mixed-method use and provide decision guidance for RSEs, principal investigators, institutions, and funders. Findings are limited to the focused review; a 727-record triaged corpus and reproducible search protocol are presented as groundwork for a future systematic mapping study.

### Source excerpt

arXiv:2611.23253v1 Announce Type: new Abstract: Research software now serves as a primary instrument of science, but the methods the community uses to judge its quality, sustainability, reuse, and impact remain scattered across software engineering, open science, FAIR software, citation, and research-assessment literature. AI-assisted development sharpens the problem: code can be produced at rates that outpace human review capacity, provenance and attribution are harder to track, scholarly credit systems cannot keep pace, and existing metrics inherit assumptions about how research software gets developed that may no longer apply. To aid in navigating these challenges, we present a focused landscape synthesis of research software metrics based on 49 substantive references, organizing the recurring metrics into eight families described by data source, claimed construct, evidence of validity, automation potential, and susceptibility to misuse. Many widely cited research software metrics serve as partial signals but make weak standalone measures of scientific impact. The AI era opens or widens gaps around provenance, maintainability of generated code, reviewer effort, model and data dependencies, reuse and community-health signal inflation, and credit for human labor that AI does not perform. We argue for responsible, contextual, mixed-method use of research software metrics, and offer decision guidance for Research Software Engineers (RSEs), principal investigators, institutions, and funders selecting metrics that support better software, fairer credit, and more trustworthy science. All findings rest on the 49-reference focused review; a reproducible search-and-triage protocol and a 727-record triaged corpus accompany the paper as a transparency artifact for a future full systematic mapping study.

## Model Discovery for Virtual Chaos Engineering with Incomplete Tracing: An eBPF Study

DevFeed: [Model Discovery for Virtual Chaos Engineering with Incomplete Tracing: An eBPF Study](<https://devfeed.tech/articles/model-discovery-for-virtual-chaos-engineering-with-incomplete-tracing-an-ebpf-study-142173.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.23313>)

Author: Anatoly A. Krasnovsky

Published: 2026-11-19T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>), [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Chaos Engineering](<https://devfeed.tech/topics/chaos-engineering.md>), [eBPF](<https://devfeed.tech/topics/ebpf.md>), [tracing](<https://devfeed.tech/topics/tracing.md>), [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>)

Tags: [association](<https://devfeed.tech/tags/association.md>), [berkeley-packet-filter](<https://devfeed.tech/tags/berkeley-packet-filter.md>), [case-study](<https://devfeed.tech/tags/case-study.md>), [chaos-engineering](<https://devfeed.tech/tags/chaos-engineering.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [discovery](<https://devfeed.tech/tags/discovery.md>), [ebpf](<https://devfeed.tech/tags/ebpf.md>), [instrumentation](<https://devfeed.tech/tags/instrumentation.md>), [legacy-systems](<https://devfeed.tech/tags/legacy-systems.md>), [model](<https://devfeed.tech/tags/model.md>), [opentelemetry](<https://devfeed.tech/tags/opentelemetry.md>), [prediction](<https://devfeed.tech/tags/prediction.md>), [protocols](<https://devfeed.tech/tags/protocols.md>), [semantics](<https://devfeed.tech/tags/semantics.md>), [study](<https://devfeed.tech/tags/study.md>), [tracing](<https://devfeed.tech/tags/tracing.md>), [virtual](<https://devfeed.tech/tags/virtual.md>)

### AI overview

The study finds that eBPF observation can support virtual fault experiments in some tested applications even when application SDK tracing is absent. Across 108 cases in three public applications, the researchers combined discovered dependencies with declared operation requirements, deployment facts, and scenario assumptions, then compared model forecasts with independent execution checks. With SDK tracing disabled, the tested OpenTelemetry eBPF Instrumentation path supported all seven operations in two applications over three repetitions; forecasts matched exactly in 17 of 21 operation-repetition groups, with a maximum state-weighted discrepancy of 4.22 percentage points. Adding observed context links supported nine more groups under partial tracing. The acquisition path remains limited by protocols, evidence association, and operation semantics.

### Source excerpt

arXiv:2611.23313v1 Announce Type: new Abstract: Model-based fault experiments can assess the consequences of component failures before intervening in a running application. Recent work on model discovery and graph simulation acquired operation models from application telemetry and used them for availability prediction. Applying this approach to operational legacy systems raises an acquisition problem: the required traces may be absent or incomplete, while introducing them can require changes across heterogeneous components. These systems continue to serve business operations during extended maintenance and modernization. External observation offers a possible route to model-based fault analysis before a tracing retrofit, but collecting telemetry does not by itself establish that an executable operation model can be obtained. We investigate this route using extended Berkeley Packet Filter (eBPF) observations and the existing graph-based modelling approach. A 108-case study varied application software development kit (SDK) tracing across absent, partial and full conditions in three public applications. Discovered dependencies were combined with declared operation requirements, deployment facts and scenario assumptions; model forecasts preceded independent execution checks. With SDK tracing disabled, the tested OpenTelemetry eBPF Instrumentation path supported all seven operations in two applications across three repetitions. Forecasts agreed exactly in 17 of 21 operation-repetition groups; the maximum state-weighted discrepancy was 4.22 percentage points. Combining observed context links supported nine additional groups under partial tracing. The results establish an acquisition path for virtual fault experiments under the tested observation constraints and identify limits imposed by protocols, evidence association and operation semantics.

## Thoughts on Verification Engineering in the Agentic SDLC

DevFeed: [Thoughts on Verification Engineering in the Agentic SDLC](<https://devfeed.tech/articles/thoughts-on-verification-engineering-in-the-agentic-sdlc-142073.md>)

Original publisher: [Read original article](<https://www.dataengineeringweekly.com/p/thoughts-on-verification-engineering>)

Author: Ananth Packkildurai

Published: 2026-11-18T21:59:55Z

Content type: article

Language: en

Sources: [Data Engineering Weekly](<https://devfeed.tech/sources/data-engineering-weekly.md>)

Topics: [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [reliability-engineering](<https://devfeed.tech/topics/reliability-engineering.md>), [observability](<https://devfeed.tech/topics/observability.md>), [Spec Driven Development](<https://devfeed.tech/topics/spec-driven-development.md>), [performance-engineering](<https://devfeed.tech/topics/performance-engineering.md>), [data-engineering](<https://devfeed.tech/topics/data-engineering.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-sdlc](<https://devfeed.tech/tags/agentic-sdlc.md>), [agentic-software](<https://devfeed.tech/tags/agentic-software.md>), [agentic-software-development](<https://devfeed.tech/tags/agentic-software-development.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agent](<https://devfeed.tech/tags/ai-agent.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [ai-coding-assistants](<https://devfeed.tech/tags/ai-coding-assistants.md>), [code](<https://devfeed.tech/tags/code.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [feedback](<https://devfeed.tech/tags/feedback.md>), [manufacturing](<https://devfeed.tech/tags/manufacturing.md>), [sdlc](<https://devfeed.tech/tags/sdlc.md>), [software](<https://devfeed.tech/tags/software.md>), [software-supply-chain](<https://devfeed.tech/tags/software-supply-chain.md>), [supply-chain](<https://devfeed.tech/tags/supply-chain.md>), [thoughts](<https://devfeed.tech/tags/thoughts.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

The article argues that AI accelerates code production faster than existing review and testing loops can verify it, shifting the engineering bottleneck toward proving behavior before release. Static analysis and human diff reviews may miss cross-service runtime failures, while relying on canaries risks exposing users to too many regressions. It proposes Verification Engineering built around disposable production-equivalent sandboxes, synthetic test data shaped by domain distributions and failure patterns, automatically generated test harnesses and correctness/performance/resource assertions, and simulated end-to-end user workflows. Requirements and designs would become executable specifications, while production logs, traces, and interactions would feed anomalies back into future sandbox tests. These are presented as a proposed discipline, not as a comparison of specific products or evidence of measured results.

### Source excerpt

When AI accelerates code manufacturing, the software supply chain bottleneck shifts from writing code to building the feedback loop that proves it works.

## Retail Merchandising Principles for Web Designers and Developers: Display Design, Ranking Rules and Measurement

DevFeed: [Retail Merchandising Principles for Web Designers and Developers: Display Design, Ranking Rules and Measurement](<https://devfeed.tech/articles/retail-merchandising-principles-for-web-designers-and-developers-display-design-ranking-rules-and-measurement-141352.md>)

Original publisher: [Read original article](<https://www.sitepoint.com/retail-merchandising-principles-for-web-designers-and-developers-display-design-ranking-rules-and-measurement/>)

Author: Div John

Published: 2026-11-18T09:46:28Z

Content type: article

Language: en

Sources: [SitePoint](<https://devfeed.tech/sources/sitepoint.md>)

Topics: [web design](<https://devfeed.tech/topics/web-design.md>), [User interface design](<https://devfeed.tech/topics/ui-design.md>), [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [rule-engine](<https://devfeed.tech/topics/rule-engine.md>), [human centric design](<https://devfeed.tech/topics/human-centric-design.md>), [information retrieval](<https://devfeed.tech/topics/information-retrieval.md>), [designer developer handoff](<https://devfeed.tech/topics/designer-developer-handoff.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>)

Tags: [accessibility](<https://devfeed.tech/tags/accessibility.md>), [accessible](<https://devfeed.tech/tags/accessible.md>), [badge](<https://devfeed.tech/tags/badge.md>), [basics](<https://devfeed.tech/tags/basics.md>), [behavior](<https://devfeed.tech/tags/behavior.md>), [brand](<https://devfeed.tech/tags/brand.md>), [campaign](<https://devfeed.tech/tags/campaign.md>), [card](<https://devfeed.tech/tags/card.md>), [change](<https://devfeed.tech/tags/change.md>), [design](<https://devfeed.tech/tags/design.md>), [designers](<https://devfeed.tech/tags/designers.md>), [developer-tools](<https://devfeed.tech/tags/developer-tools.md>), [developers](<https://devfeed.tech/tags/developers.md>), [display](<https://devfeed.tech/tags/display.md>), [measurement](<https://devfeed.tech/tags/measurement.md>), [principles](<https://devfeed.tech/tags/principles.md>), [ranking](<https://devfeed.tech/tags/ranking.md>), [retail](<https://devfeed.tech/tags/retail.md>), [rules](<https://devfeed.tech/tags/rules.md>), [web](<https://devfeed.tech/tags/web.md>), [web-designers](<https://devfeed.tech/tags/web-designers.md>)

### AI overview

E-commerce merchandising works best when product visibility, ranking, accessibility and operational upkeep are treated as explicit interface rules. The article recommends curating the first screen, limiting visual emphasis, and encoding pins, boosts, brand caps and stock demotion in testable ranking logic; its Node.js example is a teaching sketch that omits production concerns such as personalization and search relevance. Price and badge colors should meet WCAG contrast thresholds, and promotions need start and end dates plus checks to prevent stale content. For layout changes, it demonstrates a two-proportion conversion test: illustrative results rise from 3.00% to 3.90% (z=2.21), while cautioning that this is not a general guarantee and assumes a preset sample size. Test one change with randomized comparable users, and coordinate design, engineering and operations so the shipped display matches the plan.

### Source excerpt

null Continue reading Retail Merchandising Principles for Web Designers and Developers: Display Design, Ranking Rules and Measurement on SitePoint.

## Measuring Human-AI Alignment as an Early Indicator for Effective Collaboration in Hybrid SE Teams

DevFeed: [Measuring Human-AI Alignment as an Early Indicator for Effective Collaboration in Hybrid SE Teams](<https://devfeed.tech/articles/measuring-human-ai-alignment-as-an-early-indicator-for-effective-collaboration-in-hybrid-se-teams-139590.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.21633>)

Author: Andreas Metzger

Published: 2026-11-18T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>), [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [ai alignment](<https://devfeed.tech/topics/ai-alignment.md>), [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [human computer interaction](<https://devfeed.tech/topics/human-computer-interaction.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [ai-alignment](<https://devfeed.tech/tags/ai-alignment.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [assessment](<https://devfeed.tech/tags/assessment.md>), [bpm](<https://devfeed.tech/tags/bpm.md>), [business-process](<https://devfeed.tech/tags/business-process.md>), [collaboration](<https://devfeed.tech/tags/collaboration.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [declarative](<https://devfeed.tech/tags/declarative.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [human-computer-interaction](<https://devfeed.tech/tags/human-computer-interaction.md>), [measurements](<https://devfeed.tech/tags/measurements.md>), [methodology](<https://devfeed.tech/tags/methodology.md>), [metric](<https://devfeed.tech/tags/metric.md>), [metrics](<https://devfeed.tech/tags/metrics.md>), [monitoring](<https://devfeed.tech/tags/monitoring.md>), [organizational](<https://devfeed.tech/tags/organizational.md>), [paper](<https://devfeed.tech/tags/paper.md>), [performance](<https://devfeed.tech/tags/performance.md>)

### AI overview

The paper proposes measuring human-AI alignment early in software engineering teams: how closely an agent's actions and level of detail match human expectations. It argues that existing metrics emphasize run-time performance and proposes an SE-specific metric suite informed by software architecture, organizational psychology, and human-computer interaction. For validation, it outlines a business process monitoring approach and static assessment tools based on declarative BPM languages to check whether agents follow project constraints. The supplied text presents a research agenda, not evidence that the metrics or tools have been implemented or validated.

### Source excerpt

arXiv:2611.21633v1 Announce Type: new Abstract: As AI agents increasingly integrate into software engineering (SE) processes, ensuring effective collaboration in these hybrid teams becomes a critical challenge. While existing metrics focus on observing dynamic run-time performance, there is a lack of systematic, static measurements for early human-AI alignment -- the degree to which an AI's actions and granularity map to human expectations. This position paper proposes a research agenda to develop an SE-specific alignment metric suite drawing principles from software architecture, organizational psychology, and human-computer interaction. Furthermore, it outlines a validation methodology using concepts and techniques from business process monitoring (BPM) and introduces static assessment tools leveraging declarative BPM languages to ensure agents adhere to specific project constraints.

## Usage Patterns of Programming Languages and Tools: A Systematic Literature Review

DevFeed: [Usage Patterns of Programming Languages and Tools: A Systematic Literature Review](<https://devfeed.tech/articles/usage-patterns-of-programming-languages-and-tools-a-systematic-literature-review-139586.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.21627>)

Author: Sherlock A. Licorish, Natalie Grattan

Published: 2026-11-18T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [ci](<https://devfeed.tech/tags/ci.md>), [ci-tools](<https://devfeed.tech/tags/ci-tools.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [development-tools](<https://devfeed.tech/tags/development-tools.md>), [github-actions](<https://devfeed.tech/tags/github-actions.md>), [ide](<https://devfeed.tech/tags/ide.md>), [ides](<https://devfeed.tech/tags/ides.md>), [industry](<https://devfeed.tech/tags/industry.md>), [java](<https://devfeed.tech/tags/java.md>), [languages](<https://devfeed.tech/tags/languages.md>), [literature](<https://devfeed.tech/tags/literature.md>), [methodology](<https://devfeed.tech/tags/methodology.md>), [programming](<https://devfeed.tech/tags/programming.md>), [programming-languages](<https://devfeed.tech/tags/programming-languages.md>), [research](<https://devfeed.tech/tags/research.md>), [review](<https://devfeed.tech/tags/review.md>), [sampling](<https://devfeed.tech/tags/sampling.md>), [tools](<https://devfeed.tech/tags/tools.md>), [travis-ci](<https://devfeed.tech/tags/travis-ci.md>)

### AI overview

A systematic review of 37 studies published from 2015 to 2024 found Java was most often listed among popular industry programming languages, while Travis CI and GitHub Actions were the most commonly identified top CI tools. Few studies examined use of specific IDEs. The authors say evidence about industry tool popularity remains limited by methodological constraints, including lack of access to closed-source projects and sampling bias, and call for newer studies using multiple research approaches to balance those limits.

### Source excerpt

arXiv:2611.21627v1 Announce Type: new Abstract: Technology and the popularity of languages and tools are rapidly evolving. Thus, it is important to constantly assess the most popular languages and tools used in industry, furthering the collaboration between research and the software industry. In this study, we use a systematic literature review and investigate 37 studies published between 2015 -- 2024, which explored the programming languages, IDEs and CI tools used in industry. We observed that Java is most often listed among the most popular languages, and there are limited studies that investigate specific IDE usage. Also, Travis CI and GitHub Actions are the most common CI tools identified as being top CI tools used in industry. Overall, evidence shows that there is a lack of research focused on popular languages and tools used in industry, largely as there are many limitations with the possible methodology approaches. For example, lack of access to closed-source projects and sampling biases are potential issues that limit our understanding of popular languages and tools used in industry. In this regard, there is a need for more recent studies into development tools used in industry, involving multiple research approaches, to balance the limitations of each approach.

## The Software Engineering Factory: Engineering Accountability and Control in the Age of Abundant Code

DevFeed: [The Software Engineering Factory: Engineering Accountability and Control in the Age of Abundant Code](<https://devfeed.tech/articles/the-software-engineering-factory-engineering-accountability-and-control-in-the-age-of-abundant-code-139582.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.21623>)

Author: Ahmed E. Hassan, Zhe Chen, Amr E. Mohamed, Keheliya Gallaba, Daniel German, Waleed Kadous, Gustavo A. Oliva, Radin Shayanfar, Paul Stack, Haoxiang Zhang

Published: 2026-11-18T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [AI Engineering](<https://devfeed.tech/topics/ai-engineering.md>), [qualitygates](<https://devfeed.tech/topics/qualitygates.md>), [responsible-ai](<https://devfeed.tech/topics/responsible-ai.md>), [Code review](<https://devfeed.tech/topics/code-review.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>)

Tags: [acceptance](<https://devfeed.tech/tags/acceptance.md>), [accountability](<https://devfeed.tech/tags/accountability.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [building](<https://devfeed.tech/tags/building.md>), [changes](<https://devfeed.tech/tags/changes.md>), [code](<https://devfeed.tech/tags/code.md>), [code-review](<https://devfeed.tech/tags/code-review.md>), [community](<https://devfeed.tech/tags/community.md>), [control](<https://devfeed.tech/tags/control.md>), [controls](<https://devfeed.tech/tags/controls.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [dark-factory](<https://devfeed.tech/tags/dark-factory.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [factory](<https://devfeed.tech/tags/factory.md>), [software](<https://devfeed.tech/tags/software.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>)

### AI overview

The paper argues that when AI agents produce more code than people can review line by line, accountability should be built into the process rather than rely primarily on final code review. Its Software Engineering Factory uses protocols to define work stages, required evidence, and ownership; a deterministic engine written in conventional code enforces transitions and gates, with human escalation where needed. Humans retain authority by setting delegation scope, boundaries, escalation conditions, and decisions requiring judgment, without supervising every agent action. Drawing on three iterated implementations, two open source, the authors offer ten principles for designing and operating such systems. They present these as a non-exhaustive conceptual scaffold, not the only viable foundation.

### Source excerpt

arXiv:2611.21623v1 Announce Type: new Abstract: AI agents can now plan, write, test, review, and revise code at a volume no human organization can inspect line by line. Final code review therefore cannot remain the primary organizational control for owning code changes. The Software Engineering (SE) Factory moves control into the process that produces the code. The Factory protocols define how work moves, what evidence must exist before it can proceed, and who owns the result. A deterministic protocol engine, implemented in conventional code rather than prompts, enforces those protocols by controlling stage transitions, requiring evidence, and invoking gates and human escalation, where needed, before work can advance. The SE Factory preserves human authority over consequential decisions and makes accountable acceptance possible without requiring humans to supervise every agent action. The SE Factory is not a dark factory. Humans remain in control by defining the scope and granularity of delegation, the boundaries and escalation conditions, and the consequential decisions that require accountable human judgment. We draw on our experience building three distinct SE Factory implementations, all of which have undergone multiple iterations and two of which are publicly available as open-source systems, into ten principles for conceiving, building, and operating SE Factories at scale, grounded in the organizational and technical realities of our implementations. We do not claim that these principles are exhaustive or constitute the only viable foundation for an SE Factory. Rather, we offer them as a conceptual scaffold and shared vocabulary for reasoning about SE Factories, evaluating their designs, and guiding their evolution. Our goal is to catalyze a community-wide dialogue that moves software engineering beyond controls designed for human-scale code production toward a disciplined, scalable, and trustworthy agentic future.

## Reusing Battle-tested Code: A Systematic Literature Review of Automated Software Transplantation

DevFeed: [Reusing Battle-tested Code: A Systematic Literature Review of Automated Software Transplantation](<https://devfeed.tech/articles/reusing-battle-tested-code-a-systematic-literature-review-of-automated-software-transplantation-139587.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.21630>)

Author: Thanatad Songpetchmongkol, Earl T. Barr, Mark Harman, Federica Sarro, Justyna Petke

Published: 2026-11-18T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [reusable code](<https://devfeed.tech/topics/reusable-code.md>), [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [analysis](<https://devfeed.tech/tags/analysis.md>), [automated](<https://devfeed.tech/tags/automated.md>), [bottlenecks](<https://devfeed.tech/tags/bottlenecks.md>), [challenge](<https://devfeed.tech/tags/challenge.md>), [code](<https://devfeed.tech/tags/code.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [engineering-practice](<https://devfeed.tech/tags/engineering-practice.md>), [generative](<https://devfeed.tech/tags/generative.md>), [generative-ai](<https://devfeed.tech/tags/generative-ai.md>), [integration](<https://devfeed.tech/tags/integration.md>), [language-models](<https://devfeed.tech/tags/language-models.md>), [large-language-models](<https://devfeed.tech/tags/large-language-models.md>), [libraries](<https://devfeed.tech/tags/libraries.md>), [literature](<https://devfeed.tech/tags/literature.md>), [location](<https://devfeed.tech/tags/location.md>), [logic](<https://devfeed.tech/tags/logic.md>), [over](<https://devfeed.tech/tags/over.md>), [review](<https://devfeed.tech/tags/review.md>), [software](<https://devfeed.tech/tags/software.md>)

### AI overview

The review identifies 27 automated software transplantation approaches for reusing production-tested code in new host systems. Although adapting transplanted code is highly automated, locating suitable code and augmenting test suites remain significant manual bottlenecks. The authors propose a research roadmap that includes using large language models to help identify and verify valuable, production-hardened logic. The supplied excerpt does not detail individual approaches or the roadmap's specific methods.

### Source excerpt

arXiv:2611.21630v1 Announce Type: new Abstract: Software reuse remains a fundamental challenge in software engineering, often caught between the security risks of external libraries and the reliability concerns of generative AI. Automated software transplantation offers a compelling alternative by enabling the direct extraction and integration, into new host systems, of battle-tested logic (code that has already survived the rigors of production, possibly over many years of extensive in-production use). This paper presents a systematic literature review to evaluate the current state-of-the-art and identify the remaining barriers preventing this technology from becoming a mainstream engineering practice. We identified 27 distinct automated software transplantation approaches. Our analysis reveals that while the adaptation of code is highly automated, significant bottlenecks remain in the manual prerequisite steps of organ location and test suite augmentation. We conclude with a research roadmap that suggests how these manual obstacles might be overcome, including the strategic use of Large Language Models to assist in identifying and verifying high-value, production-hardened logic for transplantation.

## Trustworthy AI Teammates for Software Engineering: A Research Agenda for Lifecycle Context, Explainability, and Agentic Collaboration

DevFeed: [Trustworthy AI Teammates for Software Engineering: A Research Agenda for Lifecycle Context, Explainability, and Agentic Collaboration](<https://devfeed.tech/articles/trustworthy-ai-teammates-for-software-engineering-a-research-agenda-for-lifecycle-context-explainability-and-agentic-collaboration-139583.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.21624>)

Author: Glaucia Melo

Published: 2026-11-18T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [agentic-coding](<https://devfeed.tech/topics/agentic-coding.md>), [Agentic AI](<https://devfeed.tech/topics/what-is-agentic-ai.md>), [future of software](<https://devfeed.tech/topics/future-of-software.md>)

Tags: [accountability](<https://devfeed.tech/tags/accountability.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [ai-assisted](<https://devfeed.tech/tags/ai-assisted.md>), [ai-coding-assistants](<https://devfeed.tech/tags/ai-coding-assistants.md>), [ai-systems](<https://devfeed.tech/tags/ai-systems.md>), [ai-teammates](<https://devfeed.tech/tags/ai-teammates.md>), [alignment](<https://devfeed.tech/tags/alignment.md>), [artifacts](<https://devfeed.tech/tags/artifacts.md>), [collaboration](<https://devfeed.tech/tags/collaboration.md>), [context](<https://devfeed.tech/tags/context.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [explainability](<https://devfeed.tech/tags/explainability.md>), [lifecycle](<https://devfeed.tech/tags/lifecycle.md>), [research](<https://devfeed.tech/tags/research.md>), [software](<https://devfeed.tech/tags/software.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>), [trustworthy-ai](<https://devfeed.tech/tags/trustworthy-ai.md>)

### AI overview

The paper argues that AI coding assistants should evolve into trustworthy software engineering teammates. It identifies three requirements: lifecycle awareness across requirements and deployment artifacts, explanations that expose assumptions, evidence, trade-offs, and risks, and collaboration among specialized agents with human oversight and accountability. Its proposed evaluation framework extends beyond functional correctness to include contextual alignment, trust calibration, maintenance recovery cost, and traceability. The abstract frames these as research directions and highlights the challenge of improving software quality while preserving human understanding, agency, and responsibility.

### Source excerpt

arXiv:2611.21624v1 Announce Type: new Abstract: Large Language Models are rapidly changing software engineering (SE) practice by supporting code generation, testing, debugging, documentation, and program comprehension. Yet most current AI coding assistants remain reactive tools: they respond to local prompts, rely on limited context, and provide suggestions whose rationale is often difficult for developers to inspect. This paper argues that the next phase of AI-assisted SE requires a shift from coding assistants to trustworthy AI teammates. We present a research agenda for human-AI co-evolution in SE, organized around three requirements. First, AI systems must become lifecycle-aware, reasoning across requirements and other deployment artifacts rather than isolated files or prompts. Second, they must provide principled explanations that expose assumptions, evidence, trade-offs, and risks in ways that support developer judgment. Third, they must enable agentic collaboration, in which specialized AI agents participate in software workflows while preserving human oversight and accountability. We propose an evaluation framework that moves beyond isolated functional correctness toward collaborative quality, including contextual alignment, trust calibration, maintenance recovery cost, and traceability. We conclude by outlining open challenges for designing AI systems that improve software quality without weakening human understanding, agency, or responsibility.

[Next page](<https://devfeed.tech/topics/software-engineering.md?cursor=WyIyMDI2LTExLTE4VDA1OjAwOjAwKzAwOjAwIiwgIjg3ODcwODYzLWQ4YzAtNDcyOC1hZWVmLTMyMmJkNzlmZmZiMCJd>)