yusuke1997/dblp-id-title huggingface dataset:
How Are We Detecting Inconsistent Method Names? An Empirical Study from Code Review Perspective
AutoRIC: Automated Neural Network Repairing Based on Constrained Optimization
A verification system for interval-based specification languages
Supporting dynamic aspect-oriented features
The ASTOOT Approach to Testing Object-Oriented Programs
Achieving scalable model-based testing through test case diversity
A Practical Approach for Dynamic Taint Tracking with Control-flow Relationships
Toward More Efficient Statistical Debugging with Abstraction Refinement
Beyond Decision: Android Malware Description Generation through Profiling Malicious Behavior Trajectory
Fairness Testing: A Comprehensive Survey and Analysis of Trends
Rise of the Planet of Serverless Computing: A Systematic Review
Wireframe-based UI Design Search through Image Autoencoder
Detecting the Behavior of Design Patterns through Model Checking and Dynamic Analysis
Software Effort Interval Prediction via Bayesian Inference and Synthetic Bootstrap Resampling
The Sustainability Face of Automated Program Repair Tools
An Empirical Study on the Characteristics of Database Access Bugs in Java Applications
Automatically Generating SystemC Code from HCSP Formal Models
UML-B: Formal modeling and design aided by UML
Distinguishing GUI Component States for Blind Users Using Large Language Models
Guaranteeing Timed Opacity using Parametric Timed Model Checking
L2S: A Framework for Synthesizing the Most Probable Program under a Specification
Non-Autoregressive Line-Level Code Completion
From Today's Code to Tomorrow's Symphony: The AI Transformation of Developer's Routine by 2030
A Graphical Interval Logic for Specifying Concurrent Systems
Model Transformation Development Using Automated Requirements Analysis, Metamodel Matching, and Transformation by Example
J-Orchestra: Enhancing Java programs with distribution capabilities
Towards an Anatomy of Software Craftsmanship
Measurement of Embedding Choices on Cryptographic API Completion Tasks
Prompting Techniques for Secure Code Generation: A Systematic Investigation
System Safety Monitoring of Learned Components Using Temporal Metric Forecasting
Patching Locking Bugs Statically with Crayons
An Empirical Study on Challenges for LLM Application Developers
Tools and experiments supporting a testing-based theory of component composition
Behavior-consistent specialization of object life cycles
Post-release reliability growth in software products
On the Understandability of Design-Level Security Practices in Infrastructure-as-Code Scripts and Deployment Architectures
Hippodrome: Data Race Repair Using Static Analysis Summaries
Spectrum-Based Fault Localization in Model Transformations
Measuring the strength of information flows in programs
Composing expressive runtime security policies
Classifying data dependences in the presence of pointers for program comprehension, testing, and debugging
Microservice Security Metrics for Secure Communication, Identity Management, and Observability
On fault classes and error detection capability of specification-based testing
Efficient Verification of Concurrent Systems Using Synchronisation Analysis and SAT/SMT Solving
Killing Stubborn Mutants with Symbolic Execution
Mining Privacy Goals from Privacy Policies Using Hybridized Task Recomposition
A Baseline Model for Software Effort Estimation
Bug Analysis in Jupyter Notebook Projects: An Empirical Study
An Empirical Study of Retrieval-Augmented Code Generation: Challenges and Opportunities
A taxonomy for requirements engineering and software test alignment
Evaluating the Need for Explanations in Blockchain Smart Contracts to Reconcile Surprises
Automatic Fault Detection for Deep Learning Programs Using Graph Transformations
Security Responses in Software Development
Address translation in telecommunication features
An in-depth study of the potentially confounding effect of class size in fault prediction
Neural Solving Uninterpreted Predicates with Abstract Gradient Descent
Comparing test sets and criteria in the presence of test hypotheses and fault domains
Automated Comparison of State-Based Software Models in Terms of Their Language and Structure
A Disruptive Research Playbook for Studying Disruptive Innovations
Verifying and Quantifying Side-channel Resistance of Masked Software Implementations
Identifying Affected Third-Party Java Libraries from Textual Descriptions of Vulnerabilities and Libraries
LoGenText-Plus : Improving Neural Machine Translation Based Logging Texts Generation with Syntactic Templates
FormatFuzzer: Effective Fuzzing of Binary File Formats
A comprehensive approach for the development of modular software architecture description languages
On the Impact of Lower Recall and Precision in Defect Prediction for Guiding Search-based Software Testing
Static checking of system behaviors using derived component assumptions
Scalable Similarity-Aware Test Suite Minimization with Reinforcement Learning
Identifying Performance Issues in Cloud Service Systems Based on Relational-Temporal Features
Framework for SQL Error Message Design: A Data-Driven Approach
Equivalence analysis and its application in improving the efficiency of program slicing
MalSensor: Fast and Robust Windows Malware Classification
A formal design notation for real-time systems
CodeEditor: Learning to Edit Source Code with Pre-trained Models
Anatomizing Deep Learning Inference in Web Browsers
Backsolver: Adapting Preceding Execution Paths to Solve Constraints for Concolic Execution
Data Model Property Inference, Verification, and Repair for Web Applications
DRLMutation: A Comprehensive Framework for Mutation Testing in Deep Reinforcement Learning Systems
Experimental Results from an Automatic Test Case Generator
Novelty Not Found: Exploring Input Shadowing in Fuzzing through Adaptive Fuzzer Restarts - RCR Report
Automatically Recommend Code Updates: Are We There Yet?
Impact-Driven Process Model Repair
Reasoning about inconsistencies in natural language requirements
The Good, the Bad, and the Monstrous: Predicting Highly Change-Prone Source Code Methods at Their Inception
Variability Bugs in Highly Configurable Systems: A Qualitative Analysis
Coverage-Based Debloating for Java Bytecode
Four Dark Corners of Requirements Engineering
Do Current Language Models Support Code Intelligence for R Programming Language? RCR Report
Validation of requirements for hybrid systems: A formal approach
Parameter Coverage for Testing of Autonomous Driving Systems under Uncertainty
Toward Enhancing Privacy Preservation of a Federated Learning CNN Intrusion Detection System in IoT: Method and Empirical Study
Stochastic Performance Analysis of Global Software Development Teams
Feedback-Directed Metamorphic Testing
Precise Quantitative Analysis of Binarized Neural Networks: A BDD-based Approach
Pied-Piper: Revealing the Backdoor Threats in Ethereum ERC Token Contracts
Measuring and Mining Community Evolution in Developer Social Networks with Entropy-Based Indices
On the Practicability of Deep Learning Based Anomaly Detection for Modern Online Software Systems: A Pre-Train-and-Align Framework
Automatic high-quality reengineering of database programs by abstraction, transformation and reimplementation
Assessing the Effect of Screen Mockups on the Comprehension of Functional Requirements
Integrating automated test generation into the WYSIWYT spreadsheet testing methodology
Feature specification and automated conflict detection
Method-level Bug Prediction: Problems and Promises
Try with Simpler - An Evaluation of Improved Principal Component Analysis in Log-based Anomaly Detection
Accessibility in Software Practice: A Practitioner's Perspective
Security Weaknesses of Copilot-Generated Code in GitHub Projects: An Empirical Study
Using a functional size measurement procedure to evaluate the quality of models in MDD environments
Foundations of incremental aspect model-checking
Compiler Autotuning through Multiple-phase Learning
A Tale of Two Comprehensions? Analyzing Student Programmer Attention during Code Summarization
An Approach for Modeling Architectural Design Rules in UML and its Application to Embedded Software
Mining Unit Tests for Discovery and Migration of Math APIs
Mobile Application Online Cross-Project Just-in-Time Software Defect Prediction Framework
Inferring Extended Probabilistic Finite-State Automaton Models from Software Executions
Supporting Emotional Intelligence, Productivity and Team Goals while Handling Software Requirements Changes
Improving Automated Program Repair with Domain Adaptation
A Defect Estimator for Source Code: Linking Defect Reports with Programming Constructs Usage Metrics
Enhancing GUI Exploration Coverage of Android Apps with Deep Link-Integrated Monkey
Supporting Safety Analysis of Image-processing DNNs through Clustering-based Approaches
A logical verification methodology for service-oriented computing
A Catalog of Data Smells for Coding Tasks
Security Misconfigurations in Open Source Kubernetes Manifests: An Empirical Study
Recommending Variable Names for Extract Local Variable Refactorings
Just-In-Time Defect Prediction on JavaScript Projects: A Replication Study
Software Fairness Debt: Building a Research Agenda for Addressing Bias in AI Systems
History-Driven Fuzzing for Deep Learning Libraries
A knowledge-based method for inferring semantic concepts from visual models of system behavior
The Influence of Human Aspects on Requirements Engineering-related Activities: Software Practitioners' Perspective
The Best of Both Worlds: Combining Learned Embeddings with Engineered Features for Accurate Prediction of Correct Patches
Open Source License Inconsistencies on GitHub
Synthesis and Verification of Mission Plans for Multiple Autonomous Agents under Complex Road Conditions
Assessing the Alignment between the Information Needs of Developers and the Documentation of Programming Languages: A Case Study on Rust
SEADS: Scalable and Cost-effective Dynamic Dependence Analysis of Distributed Systems via Reinforcement Learning
The Impact of Generative AI on Creativity in Software Development: A Research Agenda
An Empirical Study of Code Simplification Methods in Code Intelligence Tasks
On the Significance of Category Prediction for Code-Comment Synchronization
Making Software Development More Diverse and Inclusive: Key Themes, Challenges, and Future Directions
Uncertainty-Aware Robustness Assessment of Industrial Elevator Systems
Requirements Are All You Need: The Final Frontier for End-User Software Engineering
A Tale of Two Cities: Software Developers Working from Home during the COVID-19 Pandemic
Do Performance Aspirations Matter for Guiding Software Configuration Tuning? An Empirical Investigation under Dual Performance Objectives
1-to-1 or 1-to-n? Investigating the Effect of Function Inlining on Binary Similarity Analysis
Reusing Convolutional Neural Network Models through Modularization and Composition
Detection of Linear Errors via Domain Testing
Testing, Validation, and Verification of Robotic and Autonomous Systems: A Systematic Review
Predicting Node Failures in an Ultra-Large-Scale Cloud Computing Platform: An AIOps Solution
Introduction to the Special Issue International Conference on Software Engineering (ICSE 2012)
Reasoning about code mobility with mobile UNITY
Lightweight Lexical Source Model Extraction
StreamGen: Model-driven Development of Distributed Streaming Applications
LLMEffiChecker: Understanding and Testing Efficiency Degradation of Large Language Models
ActivFORMS: A Formally Founded Model-based Approach to Engineer Self-adaptive Systems
Benchmarking and Categorizing the Performance of Neural Program Repair Systems for Java
A Survey of Flaky Tests
Understanding Real-Time Collaborative Programming: A Study of Visual Studio Live Share
The State of Empirical Evaluation in Static Feature Location
Vulnerability Repair via Concolic Execution and Code Mutations
Automating App Review Response Generation Based on Contextual Knowledge
Pre-implementation Method Name Prediction for Object-oriented Programming
An Experimental Determination of Sufficient Mutant Operators
Oracles for Testing Software Timeliness with Uncertainty
Diversifying Focused Testing for Unit Testing
LEAM++: Learning for Selective Mutation Fault Construction
Fixing Faults in C and Java Source Code: Abbreviated vs. Full-Word Identifier Names
Developing and debugging algebraic specifications for Java classes
Communicating Study Design Trade-offs in Software Engineering
Two case studies of open source software development: Apache and Mozilla
Causality-driven Testing of Autonomous Driving Systems
A Systematic Literature Review on the Use of Deep Learning in Software Engineering Research
Continuous Integration and Delivery Practices for Cyber-Physical Systems: An Interview-Based Study
Understanding Test Convention Consistency as a Dimension of Test Quality
Large Language Models for Software Engineering: A Systematic Literature Review
A Taxonomy of Information Attributes for Test Case Prioritisation: Applicability, Machine Learning
Marple: Detecting faults in path segments using automatically generated analyses
Analysis and applications of timed service protocols
Artificial Intelligence for Software Engineering: The Journey So Far and the Road Ahead
Toward an Objective Measure of Developers' Cognitive Activities
Metamodel-based model conformance and multiview consistency checking
GreASE: A Tool for Efficient "Nonequivalence" Checking
A Formal Explainer for Just-In-Time Defect Predictions
The Use of Description Logics in KBSE Systems
Acrobats and Safety Nets: Problematizing Large-Scale Agile Software Development
The value of design rationale information
Testing and Debugging Quantum Programs: The Road to 2030
Breaking up is hard to do: An evaluation of automated assume-guarantee reasoning
Automated Mapping of Adaptive App GUIs from Phones to TVs
Toward Formalizing Structured Analysis
DDASR: Deep Diverse API Sequence Recommendation
Fairness Testing of Machine Translation Systems
Introduction to the Special Issue on ISSTA 2013
The IDEA of Us: An Identity-Aware Architecture for Autonomous Systems
Neuron Sensitivity-Guided Test Case Selection
ContrastRepair : Enhancing Conversation-Based Automated Program Repair via Contrastive Test Case Pairs
MR-Scout: Automated Synthesis of Metamorphic Relations from Existing Test Cases
An Evolutionary Approach to Constructing Effective Software Reuse Repositories
Route: Roads Not Taken in UI Testing
Context-Aware Code Change Embedding for Better Patch Correctness Assessment
Combatting Energy Issues for Mobile Applications
On Statecharts with Overlapping
A formal approach for designing CORBA-based applications
DIG: A Dynamic Invariant Generator for Polynomial and Array Invariants
A Large-Scale Study of IoT Security Weaknesses and Vulnerabilities in the Wild
JavaScript SBST Heuristics to Enable Effective Fuzzing of NodeJS Web APIs
Checking Safety Properties Using Compositional Reachability Analysis
A Survey of Learning-based Automated Program Repair
Differential Testing of Certificate Validation in SSL/TLS Implementations: An RFC-guided Approach
Fair Enough: Searching for Sufficient Measures of Fairness
Securing the Ethereum from Smart Ponzi Schemes: Identification Using Static Features
Psychometrics in Behavioral Software Engineering: A Methodological Introduction with Guidelines
Advanced White-Box Heuristics for Search-Based Fuzzing of REST APIs
A Program Integration Algorithm that Accommodates Semantics-Preserving Transformations
Accountability in Code Review: The Role of Intrinsic Drivers and the Impact of LLMs
An Information Foraging Theory Perspective on Tools for Debugging, Refactoring, and Reuse Tasks
Faster and Better Quantum Software Testing through Specification Reduction and Projective Measurements
Dynamic Dependence Summaries
What You See is What it Means! Semantic Representation Learning of Code based on Visualization and Transfer Learning
Test conditions for fault classes in Boolean specifications
Testing Multi-Subroutine Quantum Programs: From Unit Testing to Integration Testing
Software Product Line Engineering via Software Transplantation
A Roadmap for Integrating Sustainability into Software Engineering Education
Testing Causality in Scientific Modelling Software
Practical Accuracy Estimation for Efficient Deep Neural Network Testing
Human Competitiveness of Genetic Programming in Spectrum-Based Fault Localisation: Theoretical and Empirical Analysis
Generating Test Cases for Programs that Are Coded against Interfaces and Annotations
DESEN: Specification of Sociotechnical Systems via Patterns of Regulation and Control
Simulating Reactive Systems by Deduction
Efficient path conditions in dependence graphs for software safety analysis
HumanEvalComm: Benchmarking the Communication Competence of Code Generation for LLMs and LLM Agents
Towards a Consistent Interpretation of AIOps Models
Assessing the Early Bird Heuristic (for Predicting Project Quality)
A formal model for reasoning about adaptive QoS-enabled middleware
Prove it! Inferring Formal Proof Scripts from CafeOBJ Proof Scores
Exploring Automated Assertion Generation via Large Language Models
DeepGD: A Multi-Objective Black-Box Test Selection Approach for Deep Neural Networks
Automated Support for Reproducing and Debugging Field Failures
Predicting Query Quality for Applications of Text Retrieval to Software Engineering Tasks
Dependency Update Strategies and Package Characteristics
Exploring the Impact of Code Clones on Deep Learning Software
Divide-and-Conquer: Automating Code Revisions via Localization-and-Revision
Simulating Software Evolution to Evaluate the Reliability of Early Decision-making among Design Alternatives toward Maintainability
Distributed Real-Time System Specification and Verification in APTL
NSFuzz: Towards Efficient and State-Aware Network Service Fuzzing - RCR Report
SpectAcle: Fault Localisation of AI-Enabled CPS by Exploiting Sequences of DNN Controller Inferences
FaaSLight : General Application-level Cold-start Latency Optimization for Function-as-a-Service in Serverless Computing
Code-line-level Bugginess Identification: How Far have We Come, and How Far have We Yet to Go?
Automatic Repair of Quantum Programs via Unitary Operation
Reusing d-DNNFs for Efficient Feature-Model Counting
Errata: A Formal Basis for Architectural Connection
Programming by Example Made Easy
From Formal Models to Formally Based Methods: An Industrial Experience
Reinforcement Learning Informed Evolutionary Search for Autonomous Systems Testing
The Effect of Program and Model Structure on the Effectiveness of MC/DC Test Adequacy Coverage
Identifying Crosscutting Concerns Using Fan-In Analysis
Experimental Evaluation of Parameter-Efficient Fine-Tuning for Software Engineering Tasks
Developing Cost-Effective Blockchain-Powered Applications: A Case Study of the Gas Usage of Smart Contract Transactions in the Ethereum Blockchain Platform
Context Constraints for Compositional Reachability Analysis
Reducing the Impact of Time Evolution on Source Code Authorship Attribution via Domain Adaptation
Fold2Vec: Towards a Statement-Based Representation of Code for Code Comprehension
A framework and tool support for the systematic testing of model-based specifications
The Current Challenges of Software Engineering in the Era of Large Language Models
Architecture-centric support for adaptive service collaborations
Improving Deep Assertion Generation via Fine-Tuning Retrieval-Augmented Pre-Trained Language Models
Super-optimization of Smart Contracts
Estimating Software Functional Size via Machine Learning
Why Do Developers Reject Refactorings in Open-Source Projects?
Abstraction and Refinement: Towards Scalable and Exact Verification of Neural Networks
A methodology for testing CPU emulators
Less is More: Estimating Probabilistic Rewards over Partial System Explorations
The Good, the Bad, and the Missing: Neural Code Generation for Machine Learning Tasks
Conditional Commitments: Reasoning and Model Checking
Combining Centralised and Distributed Testing
A Precise Method-Method Interaction-Based Cohesion Metric for Object-Oriented Classes
A model-checking verification environment for mobile processes
Risky Dynamic Typing-related Practices in Python: An Empirical Study
A Comprehensive View on TD Prevention Practices and Reasons for Not Preventing It
Continuous and Proactive Software Architecture Evaluation: An IoT Case
Many-Objective Software Remodularization Using NSGA-III
Unraveling Code Clone Dynamics in Deep Learning Frameworks
Suboptimal Comments in Java Projects: From Independent Comment Changes to Commenting Practices
A Formal Basis for Architectural Connection
GUing: A Mobile GUI Search Engine using a Vision-Language Model
How Software Refactoring Impacts Execution Time
Understanding Vulnerability Inducing Commits of the Linux Kernel
Computing Alignments of Well-Formed Process Models using Local Search
Estimating Probabilistic Safe WCET Ranges of Real-Time Systems at Design Stages
DiPri: Distance-Based Seed Prioritization for Greybox Fuzzing
Hierarchical Distribution-aware Testing of Deep Learning
Automatically repairing event sequence-based GUI test suites for regression testing
Using a coordination language to specify and analyze systems containing mobile components
When and How to Make Breaking Changes: Policies and Practices in 18 Open Source Software Ecosystems
A Methodology for Controlling the Size of a Test Suite
Modern Code Reviews - Survey of Literature and Practice
Degree-of-knowledge: Modeling a developer's knowledge of code
Learning Failure-Inducing Models for Testing Software-Defined Networks
Toward Better Comprehension of Breaking Changes in the NPM Ecosystem
Test Data Generation for Path Coverage of MPI Programs Using SAEO
Refactoring Multi-Level Models
Verification of Programs Sensitive to Heap Layout
Efficient Management of Containers for Software Defined Vehicles
Bias behind the Wheel: Fairness Testing of Autonomous Driving Systems
A Reduced Test Suite for Protocol Conformance Testing
Editorial: The End of the Journey
A Methodology for Exposing Risk in Achieving Emergent System Properties
DatAFLow: Toward a Data-flow-guided Fuzzer
Ethics in the Age of AI: An Analysis of AI Practitioners' Awareness and Challenges
Software reuse for scientific computing through program generation
Explaining Explanations: An Empirical Study of Explanations in Code Reviews
CodeScore: Evaluating Code Generation by Learning Code Execution
Maintaining Architecture-Implementation Conformance to Support Architecture Centrality: From Single System to Product Line Development
Enhancing Android Malware Detection: The Influence of ChatGPT on Decision-centric Task
Parallel and Distributed Incremental Attribute Evaluation Algorithms for Multiuser Software Development Environments
MET-MAPF: A Metamorphic Testing Approach for Multi-Agent Path Finding Algorithms
Input Distribution Coverage: Measuring Feature Interaction Adequacy in Neural Network Testing
The Design and Implementation of Hierarchical Software Systems with Reusable Components
Predictive Mutation Analysis via the Natural Language Channel in Source Code
On the Reproducibility and Replicability of Deep Learning in Software Engineering
Markow Analysis of Software Specifications
Towards Causal Analysis of Empirical Software Engineering Data: The Impact of Programming Languages on Coding Competitions
IFDS-based Context Debloating for Object-Sensitive Pointer Analysis
Architecting families of software systems with process algebras
Is It Hard to Generate Holistic Commit Message?
Shortening Overlong Method Names with Abbreviations
Exact scalable sensitivity analysis for the next release problem
Improving software modularization via automated analysis of latent topics and dependencies
Early Evaluation of Implementation Alternatives of Composite Data Structures Toward Maintainability
Incorporating Signal Awareness in Source Code Modeling: An Application to Vulnerability Detection
GENOA - A Customizable, Front-end-Retargetable Source Code Analysis Framework
Using Failure Cost Information for Testing and Reliability Assessment
AI for DevSecOps: A Landscape and Future Opportunities
What Could Possibly Go Wrong: Undesirable Patterns in Collective Development
Speeding Up Genetic Improvement via Regression Test Selection