yusuke1997/dblp-id-title huggingface dataset:
Towards Understanding the Behavior of Classes Using Probabilistic Models of Program Inputs
Metric Temporal Graph Logic over Typed Attributed Graphs
Using Design Metrics for Predicting System Flexibility
The KeY System: Integrating Object-Oriented Design and Formal Methods
Algebra Transformation Systems and their Composition
Towards Normal Design for Safety-Critical Systems
Hybridize Functions: A Tool for Automatically Refactoring Imperative Deep Learning Programs to Graph Execution
FPH: Efficient Non-commutativity Analysis of Feature-Based Systems
Spatial Security Policies for Mobile Agents in a Sentient Computing Environment
Analyzing Web Service Based Business Processes
HybridTiger: Hybrid Model Checking and Domination-based Partitioning for Efficient Multi-Goal Test-Suite Generation (Competition Contribution)
Consistent Integration of Models Based on Views of Visual Languages
Efficient Incremental Static Analysis Using Path Abstraction
Invariant-based Program Repair
Extracting Widget Descriptions from GUIs
Change-Preserving Model Repair
Optimising Spectrum Based Fault Localisation for Single Fault Programs Using Specifications
Yet Another Model! A Study on Model's Similarities for Defect and Code Smells
Exploring Scenario Exploration
Metamodelling and Conformance Checking with PVS
Legion: Best-First Concolic Testing (Competition Contribution)
A Correlation Framework for the CORBA Component Model
TAS and IsaWin: Tools for Transformational Program Development and Theorem Proving
System Fault Tolerance Specification: Proposal of a Method Combining Semi-formal and Formal Approaches
Checking Observational Purity of Procedures
Capturing Overlapping, Triggered, and Preemptive Collaborations Using MSCs
Type-Based Taint Analysis for Java Web Applications
Towards Log Slicing
Symbolic State Partitioning for Reinforcement Learning
Memex Is Not Enough
Tools for Secure Systems Development with UML: Security Analysis with ATPs
Dynamic Systems with Implicit State
An Empirical Study on Evolution of API Documentation
Intermodeling, Queries, and Kleisli Categories
A Data Flow Model with Frequency Arithmetic
Formal-Driven Conceptualization and Prototyping of Hypermedia Applications
Fundamental Approaches to Software Engineering - 16th International Conference, FASE 2013, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2013, Rome, Italy, March 16-24, 2013. Proceedings
A New Design Defects Classification: Marrying Detection and Correction
Measuring and Characterizing Crosscutting in Aspect-Based Programs: Basic Metrics and Case Studies
Towards UML-Based Formal Specifications of Component-Based Real-Time Software
SpecTest: Specification-Based Compiler Testing
Memory Leaks Detection in Java by Bi-abductive Inference
Reduction Rules for Colored Workflow Nets
Formalisation and Verification of Java Card Security Properties in Dynamic Logic
Transformation of Attributed Structures with Cloning
Extending Development Graphs with Hiding
Automated Analysis of Permission-Based Security Using UMLsec
AToM 3 : A Tool for Multi-formalism and Meta-modelling
An Empirical Study of Long-Lived Code Clones
Software Testing: 5th Comparative Evaluation: Test-Comp 2023
Compositional Nested Long Running Transactions
An Operational Decision Support Framework for Monitoring Business Constraints
Termination Criteria for Model Transformation
Research Issues in the Renovation of Legacy Systems
Rule-Based Refinement of High-Level Nets Preserving Safety Properties
On Model-Based Regression Testing of Web-Services Using Dependency Analysis of Visual Contracts
S2A: A Compiler for Multi-modal UML Sequence Diagrams
A Program Logic for Handling JAVA CARD's Transaction Mechanism
When Things Go Wrong: Interrupting Conversations
Ensuring Structural Constraints in Graph-Based Models with Type Inheritance
Bordeaux: A Tool for Thinking Outside the Box
SDL Profiles - Formal Semantics and Tool Support
Architectural Types Revisited: Extensible And/Or Connections
Monitoring the Future of Smart Contracts
Pyro: Generating Domain-Specific Collaborative Online Modeling Environments
A Conceptual Framework for Adaptation
Incremental Clone Detection and Elimination for Erlang Programs
FuSeBMC v4: Smart Seed Generation for Hybrid Fuzzing - (Competition Contribution)
Observational Proofs with Critical Contexts
Fundamental Approaches to Software Engineering - 28th International Conference, FASE 2025, Held as Part of the International Joint Conferences on Theory and Practice of Software, ETAPS 2025, Hamilton, ON, Canada, May 3-8, 2025, Proceedings
POGen: A Test Code Generator Based on Template Variable Coverage in Gray-Box Integration Testing for Web Applications
Transformation of Type Graphs with Inheritance for Ensuring Security in E-Government Networks
Facilitating Reuse in Multi-goal Test-Suite Generation for Software Product Lines
From Mechanized Semantics to Verified Compilation: the Clight Semantics of CompCert
Reusing Model Transformations While Preserving Properties
Model-Based Adaptation of Software Communicating via FIFO Buffers
Translation Validation for Clock Transformations in a Synchronous Compiler
Implementing Hierarchical Graph-Structures
Dynamic Resource Scheduling in Disruption-Prone Software Development Environments
Describing and Analyzing Behaviours over Tabular Specifications Using (Dyn)Alloy
Fundamental Approaches to Software Engineering, 5th International Conference, FASE 2002, held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2002, Grenoble, France, April 8-12, 2002, Proceedings
Essay on Software Engineering at the Turn of Century
Graph Transforming Java Data
Concerned About Separation
Precise Version Control of Trees with Line-Based Version Control Systems
Verifying Class Invariants in Concurrent Programs
Testing Scenario-Based Models
Just Test What You Cannot Verify!
ALBERT: A Formal Language and Its Supporting Tools for Requirements Engineering
More About TAS and IsaWin - Tools for Formal Program Development
Foundations for Query-based Runtime Monitoring of Temporal Properties over Runtime Models
Controlling the Attack Surface of Object-Oriented Refactorings
Lazy TSO Reachability
Visual Configuration of Mobile Privacy Policies
Fundamental Approaches to Software Engineering - 26th International Conference, FASE 2023, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2023, Paris, France, April 22-27, 2023, Proceedings
Automatic Generation of Use Cases from Workflows: A Petri Net Based Approach
Ready-Simulation Is Not Ready to Express a Modular Refinement Relation
Introducing Context-Based Constraints
SMT-Based Bounded Schedulability Analysis of the Clock Constraint Specification Language
Improving System Understanding via Interactive, Tailorable, Source Code Analysis
Specification and Validation of Normative Rules for Autonomous Agents
Model-Checking CSP-Z
Capturing System Designs with Formal Executable Specifications
Symbolic Detection of Assertion Dependencies for Bounded Model Checking
Mining API Error-Handling Specifications from Source Code
Proving Consistency of Pure Methods and Model Fields
Color-Blind Specifications for Transformations of Reactive Synchronous Programs
Software Product Families: Towards Compositionality
Fizzer with Local Space Fuzzing - (Competition Contribution)
Formal System Development with KIV
An Approach to Composition Motivated by wp
A Deductive Approach for Fault Localization in ATL Model Transformations
Fundamental Approaches to Software Engineering, Third Internationsl Conference, FASE 2000, Held as Part of the European Joint Conferences on the Theory and Practice of Software, ETAPS 2000, Berlin, Germany, March 25 - April 2, 2000, Proceedings
A Model for Describing Object-Oriented Systems from Multiple Perspectives
A Framework for Counterexample Generation and Exploration
A Formal Framework for Developing Adaptable Service-Based Applications
Automated Support for Building Behavioral Models of Event-Driven Systems
Fundamental Approaches to Software Engineering, Second Internationsl Conference, FASE'99, Held as Part of the European Joint Conferences on the Theory and Practice of Software, ETAPS'99, Amsterdam, The Netherlands, March 22-28, 1999, Proceedings
A Logic-Based Incremental Approach to Graph Repair
Stepwise Introduction and Preservation of Safety Properties in Algebraic High-Level Net Systems
ESBMC: Scalable and Precise Test Generation based on the Floating-Point Theory - (Competition Contribution)
Contract-Driven Development
CoVeriTest with Dynamic Partitioning of the Iteration Time Limit (Competition Contribution)
Using Maude
PASTA: An Efficient Proactive Adaptation Approach Based on Statistical Model Checking for Self-Adaptive Systems
Finding a Universal Execution Strategy for Model Transformation Networks
An Algebraic Semantics for MOF
DeepFault: Fault Localization for Deep Neural Networks
Probe Mechanism for Object-Oriented Software Testing
Measuring Aspect Cohesion
A Generalized Formal Semantic Framework for Smart Contracts
The Metamodelling Language Calculus: Foundation Semantics for UML
Theoretical Aspects of Compositional Symbolic Execution
Strengthening UML Collaboration Diagrams by State Transformations
Non-local Choice and Beyond: Intricacies of MSC Choice Nodes
Symbiosis of Static Analysis and Program Testing
From Play-In Scenarios to Code: An Achievable Dream
Formal Analysis and Verification of Self-Healing Systems
Map-Based Transparent Persistence for Very Large Models
Semantics of Architectural Specifications in CASL
Algorithms for Automatically Computing the Causal Paths of Failures
A Method for Analyzing Code Homology in Genealogy of Evolving Software
Applying Design by Contract to Feature-Oriented Programming
Fuzzy quantitative attack tree analysis
Automatic Program Repair by Fixing Contracts
Regular Inference for State Machines Using Domains with Equality Tests
TouchCost: Cost Analysis of TouchDevelop Scripts
A Simulation-Oriented Formalization for a Psychological Theory
An Expressive Semantics of Mocking
A Formal Object-Oriented Analysis for Software Reliability: Design for Verification
Formal Model-Driven Program Refactoring
A Temporal Approach to Specification and Verification of Pointer Data-Structures
A Tool to Automate Component Clustering and Identification
Automated Compositional Proofs for Real-Time Systems
A Refinement Calculus for Statecharts
Analysing UML Active Classes and Associated State Machines - A Lightweight Formal Approach
Incremental Concurrent Model Synchronization using Triple Graph Grammars
An Automata-Theoretic Approach to Hardware/Software Co-verification
Semantic Clone Detection via Probabilistic Software Modeling
From EDOC Components to CCM Components: A Precise Mapping Specification
An Institutional Approach to Communicating UML State Machines
On the Importance of Inter-scenario Relationships in Hierarchical State Machine Design
Implementing QVT-R Bidirectional Model Transformations Using Alloy
FuSeBMC_IA: Interval Analysis and Methods for Test Case Generation - (Competition Contribution)
A Domain-Specific Language for Scripting Refactorings in Erlang
Visual Specifications of Policies and Their Verification
Integrating Performance and Reliability Analysis in a Non-Functional MDA Framework
Making Software Integration Really Continuous
Bootstrapping Automated Testing for RESTful Web Services
Formal Verification of Safety & Security Related Timing Constraints for a Cooperative Automotive System
Semantic-Driven Performance Evaluation (Extended Abstract)
Variability in Software: State of the Art and Future Directions - (Extended Abstract)
Modeling Role-Based Access Control Using Parameterized UML Models
Amplifying the Benefits of Design Patterns: From Specification Through Implementation
Integrated Environment for Verifying and Running Distributed Components
Control Dependence for Extended Finite State Machines
Advances in Automatic Software Testing: Test-Comp 2022
Towards Multiple Model Synchronization with Comprehensive Systems
Comparator: A Tool for Quantifying Behavioural Compatibility
An Institution for Simple UML State Machines
On-the-Fly Synthesis of Scarcely Synchronizing Distributed Controllers from Scenario-Based Specifications
Combining Related Products into Product Lines
Proving Deadlock Freedom in Component-Based Programming
Logical Testing
Monad-Independent Hoare Logic in HASCASL
Formal Requirements Engineering Using Observer Models
Verification of Loop Parallelisations
BPEL Integration Testing
The Influences of Edge Instability on Change Propagation and Connectivity in Call Graphs
Distributed Information Management with XML and Web Services
Software Engineering: Emerging Goals and Lasting Problems
Checking Absence of Illicit Applet Interactions: A Case Study
Using Scenarios to Predict the Reliability of Concurrent Component-Based Software Systems
Sound Merging and Differencing for Class Diagrams
CLTestCheck: Measuring Test Effectiveness for GPU Kernels
Using Domain-Specific Languages for the Realization of Component Composition
Structural and Nominal Cross-Language Clone Detection
A Step-Wise Approach for Integrating QoS throughout Software Development
Automatic Conformance Testing of Web Services
Specification and Analysis of Real-Time Systems Using Real-Time Maude
Effective Analysis of Attack Trees: A Model-Driven Approach
Search-Based Design Defects Detection by Example
The Good, the Bad and the Ugly: Well-Formedness of Live Sequence Charts
Distributed Behavioural Adaptation for the Automatic Composition of Semantic Services
Foundations for Software Configuration Management Policies Using Graph Transformations
Semantically Configurable Analysis of Scenario-Based Specifications
A Generic Complete Dynamic Logic for Reasoning About Purity and Effects
RELVIEW - A System for Calculating With Relations and Relational Programming
A Graph-Based Semantics Workbench for Concurrent Asynchronous Programs
System Dependence Graphs in Sequential Erlang
Platinum: Reusing Constraint Solutions in Bounded Analysis of Relational Logic
Automatic Modeling of Opaque Code for JavaScript Static Analysis
Maintaining Consistency in Layered Architectures of Mobile Ad-Hoc Networks
Fundamental Approaches to Software Engineering - 23rd International Conference, FASE 2020, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2020, Dublin, Ireland, April 25-30, 2020, Proceedings
A Logic of Graph Constraints
Performance Modeling and Analysis of Context-Aware Mobile Software Systems
A Generic Component Framework for System Modeling
Formal Specification of Object-Oriented Meta-modelling
An Online Validator for Provenance: Algorithmic Design, Testing, and API
Formal Verification of UML Statecharts with Real-Time Extensions
Taming Multi-Variability of Software Product Line Transformations
Ultimate TestGen: Test-Case Generation with Automata-based Software Model Checking (Competition Contribution)
Formal Verification of Medical Device User Interfaces Using PVS
Fundamental Approaches to Software Engineering - 19th International Conference, FASE 2016, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2016, Eindhoven, The Netherlands, April 2-8, 2016, Proceedings
Verified Resource Guarantees for Heap Manipulating Programs
Language-Based Optimisation of Sensor-Driven Distributed Computing Applications
Composing Message Translators and Inferring Their Data Types Using Tree Automata
An Information-Based View of Representational Coupling in Object-Oriented Systems
Javanni: A Verifier for JavaScript
A Prioritization Approach for Software Test Cases Based on Bayesian Networks
Explicit Connection Actions in Multiparty Session Types
Conservative Extension in Positive/Negative Conditional Term Rewriting with Applications to Software Renovation Factories
A Description Language For Composable Components
Fundamental Approaches to Software Engineering, 21st International Conference, FASE 2018, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2018, Thessaloniki, Greece, April 14-20, 2018, Proceedings
The Dependability of Complex Socio-technical Systems
On Use Cases and Their Relationships in the Unified Modelling Language
A Process Algebra for Real-Time Programs
Inference and Evolution of TypeScript Declaration Files
Discovering Math APIs by Mining Unit Tests
Shape Refinement through Explicit Heap Analysis
Abstraction and Training of Stochastic Graph Transformation Systems
Model-Based Filtering of Combinatorial Test Suites
Meta-modeling Techniques Meet Web Application Design Tools
Certified Abstract Cost Analysis
Two-Step Transformation of Model Traversal EOL Queries for Large CDO Repositories
Concolic Testing of Front-end JavaScript
Formal Real-Time Model Transformations in MOMENT2
Library-Based Design and Consistency Checking of System-Level Industrial Test Cases
VOCE: A Virtual On-Call Engineer for Automated Alert Incident Analysis Using a Large Language Model
Formal Simulation and Analysis of the CASH Scheduling Algorithm in Real-Time Maude
A Generalized Formal Framework for Partial Modeling
GPSL: A Programming Language for Service Implementation
Summarizing Software API Usage Examples Using Clustering Techniques
Crowdsourced Bug Triaging: Leveraging Q&A Platforms for Bug Assignment
On the Correspondence Between Conformance Testing and Regular Inference
Reasoning about Substitutability at the Level of JVM Bytecode
Symbiotic 8: Parallel and Targeted Test Generation - (Competition Contribution)
Prescriptive Semantics for Big-Step Modelling Languages
Dynamic Characterization of Web Application Interfaces
VeriFuzz: Good Seeds for Fuzzing (Competition Contribution)
Engineering Self-protection for Autonomous Systems
Fundamental Approaches to Software Engineering - 14th International Conference, FASE 2011, Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2011, Saarbrücken, Germany, March 26-April 3, 2011. Proceedings
Software Quality Improvement Via Pattern Matching
Formalizing and Operationalizing Industrial Standards
EventHandler -Based Analysis Framework for Web Apps Using Dynamically Collected States
Bucketing Failing Tests via Symbolic Analysis
Translating Model Simulators to Analysis Models
Fundamental Approaches to Software Engineering, 8th International Conference, FASE 2005, Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2005, Edinburgh, UK, April 4-8, 2005, Proceedings
Design Pattern-Based Extension of Class Hierarchies to Support Runtime Invariant Checks
A Modular Model Composition Technique
Deriving Non-zeno Behavior Models from Goal Models Using ILP
Many-Valued Institutions for Constraint Specification
hol-TestGen
Enhanced Property Specification and Verification in BLAST
Specifying and Analyzing Dynamic Software Architectures
SMC4PEP: Stochastic Model Checking of Product Engineering Processes
A Hybrid Dynamic Logic for Event/Data-Based Systems
Construction of Verifier Combinations Based on Off-the-Shelf Verifiers
A Tool Suite for Multi-paradigm Specification
Automated Choreography Repair
Constructs, Concepts and Criteria for Reuse in Concurrent Object-Oriented languages
Executable Tile Specifications for Process Calculi
Performance-Based Software Model Refactoring in Fuzzy Contexts
MOBY/PLC - A Design Tool for Hierarchical Real-Time Automata
Automated Generation of Consistent Graph Models with First-Order Logic Theorem Provers
Composing Specifications of Event Based Applications
A Domain Analysis to Specify Design Defects and Generate Detection Algorithms
Compositional Learning for Synchronous Parallel Automata
Computing Program Reliability Using Forward-Backward Precondition Analysis and Model Counting
PacoSuite and JAsCo: A Visual Component Composition Environment with Advanced Aspect Separation Features
Fast Computation of Arbitrary Control Dependencies
Refining Formal Specifications of Human Computer Interaction by Graph Rewrite Rules
: Priority Aware Test Case Reduction
Interface Generation and Compositional Verification in JavaPathfinder
Fizzer: New Gray-Box Fuzzer - (Competition Contribution)
Information Preserving Bidirectional Model Transformations
Fundamental Approaches to Software Engineering - 22nd International Conference, FASE 2019, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2019, Prague, Czech Republic, April 6-11, 2019, Proceedings
Retrofitting Unit Tests for Parameterized Unit Testing
From Faults Via Test Purposes to Test Cases: On the Fault-Based Testing of Concurrent Systems
ROLA: A New Distributed Transaction Protocol and Its Formal Analysis
Runtime Enforcement Using Knowledge Bases
Evaluating Ordering Heuristics for Dynamic Partial-Order Reduction Techniques
Fundamental Approaches to Software Engineering - 17th International Conference, FASE 2014, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2014, Grenoble, France, April 5-13, 2014, Proceedings
A Process to Effectively Identify "Guilty" Performance Antipatterns
Exposing Behavioral Differences in Cross-Language API Mapping Relations
On the Implementation of @pre
Automated Model Merge by Design Space Exploration
An Automatic Verifier for Java-Like Programs Based on Dynamic Frames
Towards Formal Proof Metrics
Resource Specification for Prototyping Human-Intensive Systems
SL2SF: Refactoring Simulink to Stateflow
Compositional Verification of Secure Applet Interactions
An Ontology for Software Component Matching
A Formal Approach to Heterogeneous Software Modeling
Practical Reasoning About Invocations and Implementations of Pure Methods
Cross-Entropy-Based Replay of Concurrent Programs
Engineering Service Oriented Applications: From StPowla Processes to SRML Models
A Lightweight and Portable Approach to Making Concurrent Failures Reproducible
Parallel Program Analysis via Range Splitting
An Interface Theory for Service-Oriented Design
Heterogeneous and Asynchronous Networks of Timed Systems
FuSeBMC: A White-Box Fuzzer for Finding Security Vulnerabilities in C Programs (Competition Contribution)
Grammar Testing
Fundamental Approaches to Software Engineering, 10th International Conference, FASE 2007, Held as Part of the Joint European Conferences, on Theory and Practice of Software, ETAPS 2007, Braga, Portugal, March 24 - April 1, 2007, Proceedings
Efficient Runtime Assertion Checking of Assignable Clauses with Datagroups
Models within Models: Taming Model Complexity Using the Sub-model Lattice
Fundamental Approaches to Software Engineering, 4th International Conference, FASE 2001 Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2001 Genova, Italy, April 2-6, 2001, Proceedings
A Decision Tree Lifted Domain for Analyzing Program Families with Numerical Features
Multiple Model Synchronization with Multiary Delta Lenses
Model-Based Implementation of Parallel Real-Time Systems
Correlation Patterns in Service-Oriented Architectures
ObjectCheck: A Model Checking Tool for Executable Object-Oriented Software System Designs
Evolving a Test Oracle in Black-Box Testing
Evaluation of Expected Software Quality: A Customer's Viewpoint
Enriching OCL Using Observational Mu-Calculus
Global Reproducibility Through Local Control for Distributed Active Objects
An Operational Semantics for Stateflow
Business Process Privacy Analysis in Pleak
Combining Deductive Verification with Shape Analysis
A Family of Distributed Deadlock Avoidance Protocols and Their Reachable State Spaces
Consistency of Service Composition
Accurate and Efficient Structural Characteristic Feature Extraction for Clone Detection
The Prophecy of Undo
A Behavioral Model for Software Containers
On the Empirical Evaluation of Fault Localization Techniques for Spreadsheets
A Case Study on Using Automata in Control Synthesis
Translating Software Designs for Model Checking
A Formalisation of Constraint-Aware Model Transformations
Testing Container Classes: Random or Systematic?
FDSE: Enhance Symbolic Execution by Fuzzing-based Pre-Analysis (Competition Contribution)