yusuke1997/dblp-id-title huggingface dataset:
Toolkit for specification, validation and verification of social, legal, ethical, empathetic and cultural requirements for autonomous agents
A family of multi-concept program synthesisers in Alloy ⁎
Consistency of model transformation contracts
A System at the Cross-Roads of Functional and Logic Programming
A model of context-dependent component connectors
Applying security policies through agent roles: A JAAS based approach
Building traceable Event-B models from requirements
Heuristics for Constructing While Loops
Preface for the special issue on tool papers of the 25 th International Systems and Software Product Line Conference (SPLC 2021)
Editorial-Science of Computer Programming-25 years
Implementing aspect-oriented programming constructs as modular language extensions
Property-dependent reductions adequate with divergence-sensitive branching bisimilarity
Employing early model-based safety evaluation to iteratively derive E/E architecture design
Formal specification and verification of a coordination protocol for an automated air traffic control system
Derivation of a Parsing Algorithm in Martin-Löf's Theory of Types
Service-oriented decomposition and verification of hybrid system models using feature models and contracts
Choreographies in the wild
Reasoning about safety properties in a JVM-like environment
Test case prioritization with neuron valuation based pattern
Formal reasoning about resilient goal-oriented multi-agent systems
A Relational Calculus for Program Construction by Parts
The two paradigms of software development research
Clustering relations into abstract ER schemas for database reverse engineering
Designing and verifying distributed cyber-physical systems using Multirate PALS: An airplane turning control system case study
Atomizer: A dynamic atomicity checker for multithreaded programs
Steps Toward Mechanizing Program Transformations Using PVS
Compositional model checking with divergence preserving branching bisimilarity is lively
Categorical Semantics of Parallel Program Design
A weakest precondition calculus for BUnity
Syntactic-semantic incrementality for agile verification
The capacity-C torch problem
A global path planning Java-based system for autonomous mobile robots
Preface to the special issue on feature-oriented software development (FOSD 2009)
Preface of the special issue for AVoCS 2015
Applying a dynamic threshold to improve cluster detection of LSI
Engineering a BPEL orchestration engine as a multi-agent system
Stepwise Refinement and Concurrency: The Finite-State Case
Linking Unifying Theories of Program refinement
Proof theory for hybrid(ised) logics
Preserving the original MPI semantics in a virtualized processor environment
Integrating Different Versions of Programs with Backward and Forward Slicesa
Error checking with client-driven pointer analysis
Extending component-based design with hardware components
Automated urban train control with hybrid Event-B: 'Tackling' the rugby club problem
CLG-Trans: Contrastive learning for code summarization via graph attention-based transformer
Automatic generation of polynomial invariants of bounded degree using abstract interpretation
Tool demonstration track of MODELS'2016
Formal verification of timely knowledge propagation in airborne networks
Space consumption analysis by abstract interpretation: Inference of recursive functions
Model based component development and analysis with ComMA
Quantifying requirements volatility effects
Verifying pointer programs using graph grammars
Preface for the special issue on Interaction and Concurrency Experience 2012
On a Java computer algebra system, its performance and applications
Modeling, manipulating and evolving hybrid polystores with HyDRa
Diagnosis of package installation incompatibility via knowledge base
Analyzing best practices on Web development frameworks: The lift approach
Visually characterizing source code changes
Lost in zero space - An empirical comparison of 0.y.z releases in software package distributions
McLaren's Masterpiece
Summary-based inference of quantitative bounds of live heap objects
An object-oriented parallel programming language for distributed-memory parallel computing platforms
Typed parametric polymorphism for aspects
Special issue on the Programming Languages Track at the 23rd ACM Symposium on Applied Computing
Bridging the gap between software architecture rationale formalisms and actual architecture documents: An ontology-driven approach
Computing (optimal) embeddings of directed bigraphs
Computer algebra systems as mathematical optimizing compilers
Partition refinement of Component Interaction Automata
A general technique for proving lock-freedom
Stepwise Refinement of Parallel Algorithms
Recent software developments for special functions in the Santander-Amsterdam project
Internal axioms for domain semirings
An overview of research with Slco on seamless integration of formal verification into model-driven software engineering
Object-oriented algorithm analysis and design with Java
Modelling and verifying BDI agents with bigraphs
State space generation for the HAVi leader election protocol
Architecture of a concept-based information retrieval system for educational resources
Computing end-to-end delays in stream query processing
oZone: Layer identification in the presence of cyclic dependencies
Efficient parsing with parser combinators
Improving the success rate of applying the extract method refactoring
On the expressiveness of modal transition systems with variability constraints
Towards general theories of software engineering
desync-cc: A research tool for automatically applying disassembly desynchronization during compilation
A Language of Specified Programs
Specifying and executing optimizations for generalized control flow graphs
Asynchronous sessions with implicit functions and messages
Systematicity and generalizability in business process redesign methodologies: A systematic literature review
JastAdd--an aspect-oriented compiler construction system
A Model-Driven CASE tool for developing and verifying regulated open MAS
Communication Relations: A Paradigm for Parallel Program Design
Mechanised wire-wise verification of Handel-C synthesis
A study of potential parallelism among traces in Java programs
Realizability of schedules by stochastic time Petri nets with blocking semantics
Actor-based macroscopic modeling and simulation for smart urban planning
A formalisation of the relationship between forms of program slicing
On the Classification of Attribute Evaluation Algorithms
Generating Function Versions with Rational Strictness Patterns
Preface to the Special Issue on Coordination and Self-Adaptiveness of Software Applications
Verifying the CICS File Control API with Z/Eves: An experiment in the verified software repository
A JastAdd implementation of Oberon-0
Spill - A Logic Language for Writing Testable Requirements Specifications
Verifying the Unification Algorithm in LCF
pCSSL: A stochastic extension to MARTE/CCSL for modeling uncertainty in Cyber Physical Systems
Impacts of software community patterns on process and product: An empirical study
A visual environment for visual languages
On the interoperability of model-to-model transformation languages
Java in the High Performance Computing arena: Research, practice and experience
Inferring linear invariants with parallelotopes
On the secure implementation of security protocols
Behavioural Correctness of Data Representations
Lessons from Dutch IT-outsourcing success and failure
Small Programming Exercises 10
Checking multi-view consistency of discrete systems with respect to periodic sampling abstractions
Preface: Special Issue on Verification of Objects at Runtime Execution
Analyzing student perceptions and behaviors in the use of an engaging visualization dashboard for peer code review activities
Dynamic binary translation using run-time feedbacks
Experiences with formal engineering: Model-based specification, implementation and testing of a software bus at Neopost
Refinement-oriented models of Stateflow charts
Spanders: Distributed spanning expanders
Dynamic analysis of Java program concepts for visualization and profiling
Strictness Analysis for Higher-Order Functions
Fully symbolic TCTL model checking for complete and incomplete real-time systems
Aggregate centrality measures for IoT-based coordination
Inductive representations of RDF graphs
Preface to the Special Issue on Dependable Software Engineering: Theories, Tools and Applications (SETTA 2017)
Static insertion of safe and effective memory reuse commands into ML-like programs
A text-based syntax completion method using LR parsing and its evaluation
On Deriving a LISP Program From Its Specification
Selected contributions from the Open Source Software Certification (OpenCert) workshops
The essential similarity and differences between mathematical modeling and programming
Preface for the special issue on tool papers of the 17th International Federated Conference on Distributed Computing Techniques, DisCoTec 2022
An Exercise in Transformational Programming: Backtracking and Branch-and-Bound
Formalization of an architectural model for exception handling coordination based on CA action concepts
Modular, crash-safe refinement for ASMs with submachines
Verifying relational properties of functional programs by first-order refinement
Making explicit domain knowledge in formal system development
Model checking recursive programs interacting via the heap
Reasoning about sensing uncertainty and its reduction in decision-making for self-adaptation
Translating B to TLA + for validation with TLC
Smoothsort, an Alternative for Sorting In Situ
Flash memory efficient LTL model checking
Reactive model transformation with ATL
The Origin of a Binary-Search Paradigm
Review: The Tbilisi Symposium on Logic, Language and Computation: Selected Papers - Jonathan Ginzburg, Zurab Khasidashvili, Carl Vogel, Jean-Jacques Lévi, and Enric Vallduví (Eds.), Studies in Logic, Language and Information series of CSLI Publications and FoLLI, Stanford, 1998, xxxi + 376 pages, ISBN 1-57586-098-8
Typing and semantics of asynchronous arrows in JavaScript
Language-based software engineering
The best of both worlds: Applying secure sketches to cancelable biometrics
Two type extensions for the constraint modeling language MiniZinc
Technical Debt tracking: Current state of practice: A survey and multiple case study in 15 large organizations
Pentagons: A weakly relational abstract domain for the efficient validation of array accesses
Model checking safety and liveness via k -induction and witness refinement with constraint generation
Gradual typing for Smalltalk
A practical approach for detecting multi-tenancy data interference
Refinement of Rational End-Points Real Numbers by Means of Floating-Point Numbers
Reasoning about software reconfigurations: The behavioural and structural perspectives
An extensible argument-based ontology matching negotiation approach
Conformance notions for the coordination of interaction components
Modelling and simulation of asynchronous real-time systems using Timed Rebeca
Towards a Logical Semantics for Pure Prolog
Safe and efficient runtime testing framework applied in dynamic and distributed systems
Prototyping Dynamic Software Product Lines to evaluate run-time reconfigurations
Newton - Constraint Programming over Nonlinear Constraints
A family of test selection criteria for Timed Input-Output Symbolic Transition System models
Special issue on Systems Development by Means of Semantic Technologies
Abstract interpretation of combinational asynchronous circuits
An empirical study of aspect-oriented metrics
Seamless composition and reuse of customizable user interfaces with Spec
Computational contracts
Program generation meets program verification: A case study on number-theoretic transform
Preface to the special issue on Coordination Models and Languages (Coordination 2010)
Design and Evaluation of Coconut: Typestates for C++
Using mobile code to provide fault tolerance in tuple space based coordination languages
PAMOJA: A component framework for grammar-aware engineering
Bridging the gap between enterprise architectures and software architectures
Measuring the significance of inconsistency in the Viewpoints framework
A theory of computer instructions
Multi-objective differential evolution in the generation of adversarial examples
Are requirements elicitation sessions influenced by participants' gender? An empirical experiment
A multiple camera calibration and point cloud fusion tool for Kinect V2
An evolutionary approach to translating operational specifications into declarative specifications
Topological consistency preservation with graph transformation schemes
Combining decision procedures by (model-)equality propagation
Selected papers of the Brazilian Symposium on Programming Languages (SBLP'15+16)
Embedding the refinement calculus in Coq
Improved precision in polyhedral analysis with wrapping
Formal verification of function blocks applied to IEC 61131-3
Contracts-refinement proof system for component-based embedded systems
A study of the influence of coverage on the relationship between static and dynamic coupling metrics
Selected and extended papers from Partial Evaluation and Program Manipulation 2015 (PEPM'15)
Increasing test coverage with Hapao
Introduction to the TASE 2022 Special issue
Architecting automotive product lines: Industrial practice
Composition of Assumption-Commitment Specifications in a UNITY Style
Selected papers from the Rigorous State-Based Methods 7th International Conference, ABZ 2020, Ulm, Germany, May 27-29, 2020
Systematic Derivation of Incremental Programs
A proposal for modelling usability in a holistic MDD method
Verifying chip designs at RTL level
A spectral estimation toolkit for Java applications
Linear Prime-Number Sieves: A Family Tree
A calculus for concurrent system with higher-order streaming communication
Polymorphic subtyping in O'Haskell
The transient combinator, higher-order strategies, and the distributed data problem
An iterative approach for model-based requirements engineering in large collaborative projects: A detailed experience report
Formal agent-oriented modeling with UML and graph transformation
Tor: Modular search with hookable disjunction
Maude's module algebra
Decision-making coordination and efficient reasoning techniques for feature-based configuration
Detection of anomalies in software architecture with connectors
An empirical evaluation of RAIDE: A semi-automated approach for test smells detection and refactoring
Transformations everywhere
Formalizing hybrid systems with Event-B and the Rodin Platform
An Operational Semantics of Sharing in Lazy Evaluation
Classification of security properties in a Linda-like process algebra
Special Issue on Generative Programming and Component Engineering (Selected Papers from GPCE 2004/2005)
Special section on Foundations of Coordination Languages and Software Architectures
Preface to the special issue on success stories in model driven engineering
Functional change impact analysis in use cases: An approach based on COSMIC functional size measurement
CAN-Verify: Automated analysis for BDI agents
cf4ocl: A C framework for OpenCL
A type-directed algorithm to generate random well-typed Java 8 programs
Exhaustive property oriented model-based testing with symbolic finite state machines
Test generation for sequential nets of Abstract State Machines with information passing
Preface for the Special Issue on Graph Transformation and Visual Modeling Techniques 2013
Software visualizations for improving and measuring the comprehensibility of source code
Evaluating the impact of feature selection consistency in software prediction
Hybrid dynamical systems logic and its refinements
Basic behavioral models for software product lines: Revisited
Incremental evaluation of higher-order attributes
Flexible metaprogramming and AOP in Java
Program extraction for mutable arrays
Architecture-level software performance abstractions for online performance prediction
SATDBailiff-mining and tracking self-admitted technical debt
Derivation representation using binary subtree sets
Mining early aspects based on syntactical and dependency analyses
Handling B models in the PERF integrated verification framework: Formalised and certified embedding
Partially Interpreted Schemas for CSP Programming
On the collective sort problem for distributed tuple spaces
The GAMMA Model and Its Discipline of Programming
Automatic parallelization of canonical loops
Circular reference attributed grammars - their evaluation and applications
A tool for domain-independent model mutation
Implementing monads for C++ template metaprograms
WEST: Interactive validation of Mission-time Linear Temporal Logic (MLTL)
New software composition concepts
C++ lambda expressions and closures
Procedures and parameters in the real-time program refinement calculus
Symbolic execution of Reo circuits using constraint automata
Cooperative aspect-oriented programming
Use case evolution analysis based on graph transformation with negative application conditions
On observed reproducibility in network configuration management
Integrating software engineering theory and practice using essence: A case study
An industrial experience report on model-based, AI-enabled proposal development for an RFP/RFI
Backward under-approximations in numeric abstract domains to automatically infer sufficient program conditions
Global computing in a dynamic network of tuple spaces
Some Notes on Putting Formal Specifications to Productive Use
Selected papers from the 25th Brazilian Symposium on Formal Methods - SBMF 2022
Concurrency control generation for dynamic threads using discrete-event systems
An exploratory study on automatic identification of assumptions in the development of deep learning frameworks
Preface to the special issue on advances in Smalltalk based systems
A tool for visual and formal modelling of software designs
Software architecture design for streaming Java RMI
WSDL term tokenization methods for IR-style Web services discovery
Fundamentals of Software Engineering (extended versions of selected papers of FSEN 2017)
An architecture for access control management in collaborative enterprise systems based on organization models
FeatureIDE: An extensible framework for feature-oriented software development
Rule-based refinement of high-level nets preserving safety properties
Specification and (property) inheritance in CSP-OZ
Concurrent determination of connected components
Towards an algebraic specification of code generation
Preface of the special issue on Foundational and Practical Aspects of Resource Analysis (FOPARA) 2009 & 2011
Formal development of multi-agent systems using MAZE
Preface to the special issue on Software Support for User Interface Description Languages (UIDL 2011)
A bargaining-specific architecture for supporting automated service agreement negotiation systems
Model transformations across views
Timed behavioural modelling and affine scheduling of embedded software architectures in the AADL using Polychrony
Reasoned modelling critics: Turning failed proofs into modelling guidance
On logic programs that always succeed
Shared contract-obedient channels
Structured development of implementations for divide-and-conquer specifications
Six strategies for generalizing software engineering theories
The Modeling Assistant Recommender: A UML class diagram recommender system
MMINT-A: A framework for model-based safety assurance
Regulations and software evolution: An example from the military domain
Formal analysis of privacy in Direct Anonymous Attestation schemes
PPPJ 2006 special issue - foreword
An insight into the dispersion of changes in cloned and non-cloned code: A genealogy based empirical study
A Java-based approach for teaching principles of adaptive and evolvable software
A provably safe controller for the needle-steering problem using online strategy synthesis
A B model for ensuring soundness of a large subset of the Java Card virtual machine
Tools and Software at the Systems and Software Product Line Conference (SPLC 2022 and 2023)
Light combinators for finite fields arithmetic
Event-B formalization of a variability-aware component model patterns framework
Exploiting step semantics for efficient bounded model checking of asynchronous systems
On the expressiveness of coordination via shared dataspaces
Correctness-guaranteed strategy synthesis and compression for multi-agent autonomous systems
Advances in interpreters, virtual machines and emulators
Controlling timed automata against MTL specifications with TACoS
Comprehensive synchronization elimination for Java
Servilla: A flexible service provisioning middleware for heterogeneous sensor networks
Combining partial evaluation and staged interpretation in the implementation of domain-specific languages
A process-theoretic approach to supervisory coordination under partial observation
Optimizing the representation of intervals
A unified ordering for termination proving
Typed connector families and their semantics
GaMoVR: Gamification-based UML learning environment in virtual reality
Small Programming Exercises 4
The annotated dependency pair framework for almost-sure termination of probabilistic term rewriting
Verified simulation for robotics
Sound static analysis of regular expressions for vulnerabilities to denial of service attacks
Usage contracts: Offering immediate feedback on violations of structural source-code regularities
Specifying linked data structures in JML for combining formal verification and testing
Compositional verification of a communication protocol for a remotely operated aircraft
Live and let die: LSC based verification of UML models
Selected papers from the Brazilian Symposium on Formal Methods (SBMF 2011)
Defining the meaning of tabular mathematical expressions
A top-down strategy to reverse architecting execution views for a large and complex software-intensive system: An experience report
A method and tool for tracing requirements into specifications
Incompleteness of relational simulations in the blocking paradigm
Termination of Rewriting Systems by Polynomial Interpretations and Its Implementation
A monitoring tool for linear-time μ HML
VeGAn-Tool: A fuzzy-logic approach for value-based goal model analysis
TDFix: A lightweight tool for fixing deadlocks based on templates
Parallel parsing made practical
Guest editors' foreword
Human-in-the-loop online just-in-time software defect prediction: What have we achieved and what do we still miss?
Comparing the performance of concurrent hash tables implemented in Haskell
Exceptions for Algebraic Specifications: On the Meaning of "but"
Preface to the special section on Formal Methods for Industrial Critical Systems (FMICS 2009 + FMICS 2010)
Formal modeling of evolving self-adaptive systems
On-the-fly parallel model checking algorithm that is optimal for verification of weak LTL properties
A method and a language for constructing iterative programs
Making the Most of Formal Specification Through Animation, Testing and Proof
Efficient memory management for concurrent programs that use message passing
On the static and dynamic extents of delimited continuations
Fundamentals of Software Engineering (selected papers of FSEN 2011)
Formal methods in practice
Systematic Design of an Algorithm for Biconnected Components
First-past-the-post games
About "trivial" software patents: The IsNot case
Multi-task Ada code generation from synchronous dataflow programs on multi-core: Approach and industrial study
Reconfigurable GSPNs: A modeling formalism of evolvable discrete-event systems
Extended designs algebraically
Probabilistic model checking for human activity recognition in medical serious games
Transformational Program Development in a Particular Program Domain
RML: Theory and practice of a domain specific language for runtime verification
Model checking with memoisation for fast overtaking planning
Adaptive service provisioning for enhanced energy efficiency and flexibility in wireless sensor networks
A discrete-time UML semantics for concurrency and communication in safety-critical applications
The Crippled Queen Placement Problem
A tool for publishing reproducible algorithms & A reproducible, elegant algorithm for sequential experiments