yusuke1997/dblp-id-title huggingface dataset:
State merging for concolic testing of event-driven applications
A Java-based digital library portal for geography education
Recovery of jump table case statements from binary code
Model-driven architecture for embedded software: A synopsis and an example
SMT-based robust model checking for signal temporal logic
Parallel actor monitors: Disentangling task-level parallelism from data partitioning in the actor model
A comparison of identity merge algorithms for software repositories
Longest Segment Problems
Preface for "Selected papers from the 26th Ibero-American Conference on Software Engineering (CIbSE 2023)"
Safety assurance of an industrial robotic control system using hardware/software co-verification
Benchmarking IT operations cost based on working time and unit cost
Basic Polymorphic Typechecking
Interface descriptions for enterprise architecture
EvoMBT: Evolutionary model based testing
On-the-fly construction of provably correct service compositions - templates and proofs
Multi-agent systems with virtual stigmergy
Subsumption, correctness and relative correctness: Implications for software testing
Special issue on Tools at the 29th IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER 2022)
Preface for the special issue on "Fundamental Approaches to Software Engineering" (FASE 2022)
Cost-effective evolution of research prototypes into end-user tools: The MACH case study
DPFuzz: A fuzz testing tool based on the guidance of defect prediction
Architectural pattern to improve the definition and implementation of eLearning ecosystems
SCP special issue on the grand challenge - Preface
Cultural scene detection using reverse Louvain optimization
Establishing local temporal heap safety properties with applications to compile-time memory management
Coordination with multicapabilities
Operationally proving memory access violations in Isabelle/HOL
Correctness issues on MARTE/CCSL constraints
Auto-active verification of distributed systems and specification refinements with Why3-do
Understanding software developers' cognition in agile requirements engineering
Logic Programming and Rapid Prototyping
DiaSuite: A tool suite to develop Sense/Compute/Control applications
A verified algebra for read-write Linked Data
Enriching UsiXML language to support awareness requirements
SApHESIA: An agent-based model and a criticality-based heuristic for cooperatively coupling SoSs
Loop invariance with break and continue
Preface: Special section on foundations of coordination languages and software architectures (selected papers from FOCLASA'10)
AllSynth: A BDD-based approach for network update synthesis
Type inference for a distributed \pi-calculus
Conditional termination of loops over heap-allocated data
Fundamentals of Software Engineering (selected papers of FSEN 2013)
VLSI Programming for the Compact Disc Player
Preface for the Special Issue on the 23rd Asia-Pacific Software Engineering Conference (APSEC) 2016
Soft component automata: Composition, compilation, logic, and verification
Frenetic-lib: An extensible framework for search-based generation of road structures for ADS testing
Preface for the special issue of the 11th International Symposium on Formal Aspects of Component Software
Multimodal information fusion for software vulnerability detection based on both source and binary codes
Testing non-commutativity of reduce functions with multi-column inputs
Component simulation-based substitutivity managing QoS and composition issues
Typing linear algebra: A biproduct-oriented approach
On tackling quality threats for the assessment of measurement programs: A case study on the distribution of metric usage and knowledge
Using established Web Engineering knowledge in model-driven approaches
Orchestration for quantum services: The power of load balancing across multiple service providers
Type inference and strong static type checking for Promela
Evolutionary and collaborative software architecture recovery with Softwarenaut
Merging cloned Alloy models with colorful refactorings
A Type System for Implicit Scaling
Field-sensitive unreachability and non-cyclicity analysis
Selected papers from the 14th international symposium on Theoretical Aspects of Software Engineering
Deriving relational programs for computing kernels by reconstructing a proof of Richardson's theorem
Automated code transformation for distributed training of TensorFlow deep learning models
Preface to the special issue on software evolution, adaptability and variability
Ready, set, Go!: Data-race detection and the Go language
Inferring non-failure conditions for declarative programs
On the semantics of software adaptation
Predictive access control for distributed computation
Preface to the special section on Language Descriptions Tools and Applications (LDTA'08 & '09)
Incremental computing with data structures
Experiences on teaching alloy with an automated assessment platform
Stepwise Refinement of Communicating Systems
Formal methods and finite element analysis of hurricane storm surge: A case study in software verification
Facilitating professionals' work-based learning with context-aware mobile system
Interleaving semantics and verification of UML 2 dynamic interactions using process algebra
Lub: A pattern for fine grained behavior adaptation at runtime
Modeling and verification of component connectors in Coq
Advances of proof scores in CafeOBJ
Safety-Level Communication in Railway Interlockings
Toward a prioritization approach for third-party software library updates
Pigs from sausages? Reengineering from assembler to C via FermaT transformations
Selected Papers from the Eleventh International Conference on Coordination Models and Languages
Live Robot Programming: The language, its implementation, and robot API independence
A method for rigorous design of reconfigurable systems
On the syntactic and functional correspondence between hybrid (or layered) normalisers and abstract machines
A Bottom-Up Polymorphic Type Inference in Logic Programming
Preface: Special issue on Foundations of Coordination Languages and Self-adaptive Systems
Experience with correctness-by-construction
Programming language foundations in Agda
Toward safe and efficient reconfiguration with Concerto
Grammar Zoo: A corpus of experimental grammarware
FBDTester 2.0: Automated test sequence generation for FBD programs with internal memory states
A pragma based C++ framework for hybrid quantum/classical computation
Metal: A Formalism to Specify Formalisms
A Systolic LRU Processor and Its Top-Down Development
Special section on Mutation testing (Mutation 2010)
Partial Order and Contextual Net Semantics for Atomic and Locally Atomic CC Programs
Interval-based data refinement: A uniform approach to true concurrency in discrete and real-time systems
Label Algebras and Exception Handling
Preventing arithmetic overflows in Alloy
Une Extension de VLISP vers les Objets
Using Rewriting Techniques to Produce Code Generators and Proving Them Correct
The algebraic structure of interfaces
Kin2. A Kinect 2 toolbox for MATLAB
The design and implementation of Object Grammars
Mode-Automata: a new domain-specific construct for the development of safe critical systems
Formalizing SPARCv8 instruction set architecture in Coq
Log analysis and system monitoring with nfer
Predicate transformer semantics of a higher-order imperative language with record subtyping
An MDE-based framework to support the development of Mixed Interactive Systems
Stores as Homomorphisms and Their Transformations: A Uniform Approach to Structured Types in Imperative Languages
Variant-based satisfiability in initial algebras
Formal semantics, modular specification, and symbolic verification of product-line behaviour
A customizable approach to full lifecycle variability management
Towards partial monitoring: Never too early to give in
Foreword: Selected Papers of TAPSOFT'93
Linked weak reference arrays: A hybrid approach to efficient bulk finalization
Proofs with Graphs
Guest editorial for the special issue from the 18th Brazilian Symposium on Formal Methods (SBMF 2015)
Imperative objects as mobile processes
Constraints to Stop Deforestation
Actor-based slicing techniques for efficient reduction of Rebeca models
A Semantics for Shape
Detecting Feature Interactions with CÆSAR/ALDÉBARAN
From regexes to parsing expression grammars
An Abstract Interpretation for Estimating Uncaught Exceptions in Standard ML Programs
Channel-based coordination via constraint satisfaction
MoULDyS: Monitoring of autonomous systems in the presence of uncertainties
A text classification approach to API type resolution for incomplete code snippets
On the Mathematics of Sequential Decompositions
Improving static analyses of C programs with conditional predicates
Left-Bottom and Right-Top Segments
A survey of fault localization techniques in computer networks
Axioms as generic rewrite rules in C++ with concepts
Reshape your layouts, not your programs: A safe language extension for better cache locality
LR-Parsing Derived
Candidate test set reduction for adaptive random testing: An overheads reduction technique
A framework for verifying deadlock and nondeterminism in UML activity diagrams based on CSP
Systematic derivation of correct variability-aware program analyses
Connectors as designs: Modeling, refinement and test case generation
Safe Ambients: Abstract machine and distributed implementation
Preface for special issue on Model Driven Development: Extended versions of selected papers from MODELSWARD 2014
Introduction - the LDTA tool challenge
Abstraction over implementation structure with symmetrically encapsulated multimethods
Incremental construction of systems: An efficient characterization of the lacking sub-system
Model checking and performance evaluation with CADP illustrated on shared-memory mutual exclusion protocols
Improving refactoring tools in Smalltalk using static type inference
Modular unification of unilingual pointer analyses to multilingual FFI-based programs
Preface to the special section on Object-Oriented Programming and Systems (OOPS 2010)
Improving workflow modularity using a concern-specific layer on top of Unify
Type-safe method inlining
Relational characterizations of system fault tolerance
A finite alternation result for reversible boolean circuits
Memoized zipper-based attribute grammars and their higher order extension
Verification of linear hybrid systems with large discrete state spaces using counterexample-guided abstraction refinement
Technology transfer: Formal analysis, engineering, and business value
Compositional compiler construction: Oberon0
Foreword: Selected Papers of ESOP'94
Dynamic consistency in process algebra: From Paradigm to ACP
Preface (Selected Papers from the Third International Conference on the Mathematics of Program Construction)
PTRebeca: Modeling and analysis of distributed and asynchronous systems
The Matrix as In-Situ Data Structure
Static analysis of linear absolute value equalities among variables of a program
Two Classes of Boolean Functions for Dependency Analysis
Preface for the Special Issue of the 12th Conference on Reversible Computation (RC 2020)
The supportive effect of patterns in architecture decision recovery - A controlled experiment
Special issue on the Programming Languages track at the 25th ACM Symposium on Applied Computing
Multi-agent oriented programming with JaCaMo
Denotational Engineering
Preface to the special issue: Architecture-Driven Semantic Analysis of Embedded Systems
A study of risk-aware program transformation
Structured Gamma
Out of step: Code clone detection for mobile apps across different language codebases
Assessing the SALSA architecture for developing agent-based ambient computing applications
FM fact label
Visual assessment of software evolution
Introduction to reversal fuzzy switch graph
Random test generators demystified: Differences and potential for compiler reliability
Latch: Enabling large-scale automated testing on constrained systems
Ranking architecturally critical agglomerations of code smells
A Simple Livelock-Free Algorithm for Packet Switching
Path-guided conformance test case generation for models with data and time using symbolic execution techniques
Building certified libraries for PCC: dynamic storage allocation
Memoizing Purely Functional Top-Down Backtracking Language Processors
AutoCRUD: Automatic generation of CRUD specifications in interaction flow modelling language
TrABin: Trustworthy analyses of binaries
Transforming Web Services Choreographies with priorities and time constraints into prioritized-time colored Petri nets
Evolutionary Computing to solve product inconsistencies in Software Product Lines
Principled software microengineering
Byte code level cross-compilation for developing web applications
Specification and Verification of Various Distributed Leader Election Algorithms for Unidirectional Ring Networks
Conditions for incremental iteration: Examples and counterexamples
Finding available services in TOSCA-compliant clouds
Embedding attribute grammars and their extensions using functional zippers
Unifying modal interface theories and compositional input/output conformance testing
Formalizing and Implementing Gries' Program Development Method in Dynamic Logic
Building ubiquitous QoC-aware applications through model-driven software engineering
Weak CCP bisimilarity with strong procedures
Relational Programming Laws in the Tree, List, Bag, Set Hierarchy
Goto elimination in program algebra
The CodeSparks Framework - Augmenting Source Code with Glyph-based Visualizations
Experience of building an architecture-based generator using GenVoca for distributed systems
PiDuce - A project for experimenting Web services technologies
Kraken: A framework for enabling multi-device interaction-based testing of Android apps
Efficient deadlock analysis of component-based software architectures
Efficient on-the-fly model-checking for regular alternation-free mu-calculus
Automating exception-safety classification
A Mathematical Definition of Full Prolog
Constrained synthesis from component libraries
The links between human error diversity and software diversity: Implications for fault diversity seeking
Verification of Programs That Destructively Manipulate Data
Microservices simulator: An object-oriented framework for transactional causal consistency
Function translations and search-based transformation for MVL reversible circuit synthesis
Preface for the special issue on selected software artifacts from DisCoTec 2023 - the 18th International Federated Conference on Distributed Computing Techniques
Achieving seamless component composition through scenario-based deep adaptation and generation
SAMOS - A framework for model analytics and management
Taming distributed system complexity through formal patterns
Towards Pointer Algebra
The Embedded Software of an Electricity Meter: An Experience in Using Formal Methods in an Industrial Project
Formal proof of a program: Find
Robustness testing for software components
Integration of SMT-solvers in B and Event-B development environments
Dependability in open proof software with hardware virtualization - The railway control systems perspective
OnTrack: Reflecting on domain specific formal methods for railway designs
An algorithm to test the conflict preorder
A coordination model of pervasive service ecosystems
Early knowledge organization assisted by aspects
PRIMA-UML: a performance validation incremental methodology on early UML diagrams
A Logic for Reasoning Equationally in the Presence of Partiality
CrimeSPOT: A language and runtime for developing active wireless sensor network applications
Stochastic formal model of PI3K/mTOR pathway in Alzheimer's disease for drug repurposing: An evaluation of rapamycin, LY294002, and NVP-BEZ235
A generic framework for n-protocol compatibility checking
Internal Design of Modules Specified in the Trace Assertion Method
Science Code.Net: Object-oriented programming for science
Software composition and verification for sensor networks
Bidirectionality in flow-sensitive demand-driven analysis
Domains: Safe sharing among actors
Towards a verified transformation from AADL to the formal component-based language FIACRE
Capability passing processes
Introduction to the Special Issue on Automatic Program Generation for Embedded Systems
Small Programming Exercises 21
A Java-based system for building animated presentations over the Web
Inference rules for generic code migration of aspect-oriented programs
Formal specification and validation of the MVM-Adapt system using Compositional I/O Abstract State Machines
The transformation of requirements into software primitives: Studying evolvability based on systems theoretic stability
Featherweight Java with dynamic and static overloading
Automatic validation of code-improving transformations on low-level program representations
An approach to the integration of accessibility requirements into a user interface development method
Review: Communicating and Mobile Systems: the -calculus, - Robin Milner, Cambridge University Press, Cambridge, 1999, 174 pages, ISBN 0-521-64320-1
Correctness of data representations involving heap data structures
An assembler and disassembler framework for Java TM programmers
Toward a novel taxonomy to capture code smells caused by refactoring
MiniMAO: An imperative core language for studying aspect-oriented reasoning
Introduction to the ABZ 2016 Special issue
Generalising monads to arrows
Reducing the verification cost of evolving product families using static analysis techniques
A programming framework for distributed computing continuum systems
Empirically evaluating Greedy-based test suite reduction methods at different levels of test suite complexity
A two-level formal model for Big Data processing programs
Implementation and design of a service-based framework to integrate personal and institutional learning environments
Statically identifying XSS using deep learning
Tuning research tools for scalability and performance: The NiCad experience
A modular foreign function interface
A text-based approach to feature modelling: Syntax and semantics of TVL
Preface to special issue on Generative Programming and Component Engineering (GPCE 2007)
Efficient symbolic computation of process expressions
Preface to SCP special issue with extended selected papers from SBMF 2014
Aspect-oriented programming for reactive systems: Larissa, a proposal in the synchronous framework
Reconciling statechart semantics
On the semantics of communicating hardware processes and their translation into LOTOS for the verification of asynchronous circuits with CADP
Reversible computing and implicit computational complexity
NewWave: Workflow engine
An empirical study on inconsistent changes to code clones at the release level
Two techniques to improve the precision of a demand-driven null-dereference verification approach
Special issue on Application-oriented aspects of graphs and graph transformation (ICGT 2020)
An industrial experience of using reference architectures for mapping features to code
SCP special issue on Bytecode 2012 - Preface
Formalizing hierarchical scheduling for refinement of real-time systems
Weighted pushdown systems and their application to interprocedural dataflow analysis
QMaxUSE: A new tool for verifying UML class diagrams and OCL invariants
Debugopt: Debugging fully optimized natively compiled programs using multistage instrumentation
Implementing record and refinement for debugging timing-dependent communication
Domain-specific language engineering for large-scale graph analytics using Spoofax: An industry report
Modular grammar specification
The sampling threat when mining generalizable inter-library usage patterns
Supporting change impact analysis for intelligent agent systems
Report to the readership
The IELR(1) algorithm for generating minimal LR(1) parser tables for non-LR(1) grammars with conflict resolution
SMORE: Towards a semantic modeling for knowledge representation on social media
A formal, scalable approach to semantic interoperability
Agile validation of model transformations using compound F-Alloy specifications
Centralized coordination vs. partially-distributed coordination with Reo and constraint automata
Verification of quantum programs
Component-based software architectures: a framework based on inheritance of behavior
Accelerating error-tolerant applications with approximate function reuse
Nondeterministic Data Flow Programs: How to Avoid the Merge Anomaly
A Coq library for internal verification of running-times
Deriving a Class of Layer-Oriented Graph Algorithms
Specification refinements: Calculi, tools, and applications
An Experiment in Automatic Generation of Test Suites for Protocols with Verification Technology
Semantics of programming languages: Using Asf+Sdf
Web Augmentation: A systematic mapping study
Access control in feature-oriented programming
ULKB Logic: A HOL-based framework for reasoning over knowledge graphs
Failure-free coordinators synthesis for component-based architectures
Serialisable multi-level transaction control: A specification and verification
Automatic library migration for the generation of hardware-in-the-loop models
A calculus for dynamic architectures
Introduction to the Software Quality for Artificial Intelligence (SQA4AI) special issue
Decoupling web application concerns through weaving operations
A Calculus of Total Correctness for Communicating Processes
A Systematic Design of a Parallel Program for Dirichlet Convolution
In search of a program generator to implement generic transformations for high-performance computing
Refinement algebra with dual operator
Constrained narrowing for conditional equational theories modulo axioms
Execution levels for aspect-oriented programming: Design, semantics, implementations and applications
Towards the systematic analysis of non-functional properties in Model-Based Engineering for real-time embedded systems
Preface - 22nd Brazilian Symposium on Formal Methods - SBMF 2019
Performance evaluation of virtual execution environments for intensive computing on usual representations of multidimensional arrays
A case study of using grounded analysis as a requirement engineering method: Identifying personas that specify privacy and security tool users
Deductive Synthesis of the Unification Algorithm
Understanding software artifact provenance
Theorizing about software development practices
An ontology-based approach with which to assign human resources to software projects
Software requirements and architecture modeling for evolving non-secure applications into secure applications
The impact of meta-tracing on VM design and implementation
A Sound Polymorphic Type System for a Dialect of C
Small Programming Exercises 20
Universal (meta-)logical reasoning: Recent successes
A symbolic semantics for abstract model checking
Parallel set similarity join on big data based on Locality-Sensitive Hashing
On a formal semantics of tabular expressions
Small Programming Exercises 1
Service composition with consideration of interdependent security objectives
Language support for model-driven software development
Multiple intermediate structure deforestation by shortcut fusion
Preface for the special issue on "Selected Papers and Tools of the 26th International Conference on Fundamental Approaches to Software Engineering" (FASE 2023)
Parglare: A LR/GLR parser for Python
Enhancing automated loop invariant generation for complex programs with large language models
Quantifying forecast quality of IT business value
Detecting broken pointcuts using structural commonality and degree of interest
Stream processing coalgebraically
Small Programming Exercises 13
Integrating behavioral semantic analysis in usage-based equivalent tests generation for mobile applications
Compositionality and locality for improving model checking in the selective mu-calculus
Model checking and verification of a rail-side protection system
TyphonML: Tool support for hybrid polystores
An experimental comparison of edge, edge-pair, and prime path criteria
Model-based mutation testing via symbolic refinement checking
Executable formal specifications of complex distributed systems with CoreASM
Implementing an environment for hybrid software evaluation
A formal model of service-oriented dynamic object groups
Parameterised three-valued model checking