yusuke1997/dblp-id-title huggingface dataset:
Deriving Some Expansion Theorems for Nonlinear Functional Equations by an Algorithm
NOD4J: Near-omniscient debugging tool for Java using size-limited execution trace
It is pointless to point in bounded heaps
Provably correct conflict prevention bands algorithms
tAPP OpenWhisk: A serverless platform for topology-aware allocation priority policies
Program Families: Program Construction by Context Independent Refinements
Dynamic Typing: Syntax and Proof Theory
Using Branching Time Temporal Logic to Synthesize Synchronization Skeletons
Transformation by interpreter specialisation
Flexible learning itinerary vs. linear learning itinerary
Self-certification and trust in component procurement
DopSteg: Program steganography using data-oriented programming
Predicting software effort from use case points: A systematic review
Gitana: A software project inspector
A Theory of Primitive Objects: Second-Order Systems
A High-Level Derivation of Global Search Algorithms (with Constraint Propagation)
A methodological approach for user interface development of collaborative applications: A case study
A polymorphic RPC calculus
A scalable multiagent system architecture for interactive applications
On the random structure of behavioural transition systems
Special section on Software Verification and Testing
Selected papers of the Refinement Workshop Turku (2008)
REUBI: A Requirements Engineering method for ubiquitous systems
Towards a next-generation AOSE methodology
HFCommunity: An extraction process and relational database to analyze Hugging Face Hub data
Report on selected papers from LDTA 2003
State-taint analysis for detecting resource bugs
Foreword (Selected Papers of ESOP '90)
JetsonLEAP: A framework to measure power on a heterogeneous system-on-a-chip device
How to benefit from newbies' domain ignorance in software development projects
Symbolic counterexample generation for large discrete-time Markov chains
On the semantics of parsing actions
A design-by-contract approach to recover the architectural style from run-time misbehaviour
Applying model-driven engineering to the domain of chatbots: The Xatkit experience
User-driven diverse scenario exploration in model finders
A hierarchical verification approach to verify complex safety control systems based on STAMP
Enabling analysis for Event-B
Special issue on Automated Verification of Critical Systems (AVoCS'11)
Simulation-based matching of cloud applications
The Mealy-machine reduction functions of Spot
Morris' tree traversal algorithm reconsidered
On interval dynamic logic: Introducing quasi-action lattices
An action compiler targeting Standard ML
CScout: A refactoring browser for C
Evaluating a continuous feedback strategy to enhance machine learning code smell detection
Design and architecture of an interactive eTextbook - The OpenDSA system
Ordering from Satan's menu: a survey of requirements specification for formal analysis of cryptographic protocols
Reasoning Algebraically about Recursion
Adaptive just-in-time value class optimization for lowering memory consumption and improving execution time performance
Automated verification of function block-based industrial control systems
Large-scale Model-Driven Engineering of web user interaction: The WebML and WebRatio experience
Banzai+Tatoo: Using cutting-edge parsers for implementing high-performance servers
An Algorithm for Type-Checking Dependent Types
On flexible dynamic trait replacement for Java-like languages
Avoiding code pitfalls in Aspect-Oriented Programming
Operational semantics of proto
On the specification of modal systems: A comparison of three frameworks
Zone-based formal specification and timing analysis of real-time self-adaptive systems
Detecting Stack-Based Environments in Denotational Definitions
End-user abstractions for meta-control: Reifying the reflectogram
Phase-based visualization and analysis of Java programs
Designing the automatic transformation of visual languages
Verification and test generation for the SSCOP protocol
Model-checking CSP-Z: strategy, tool support and industrial application
A Boyer-Moore-style algorithm for regular expression pattern matching
Multi-stage programming with functors and monads: Eliminating abstraction overhead from generic code
Validating and verifying the requirements and design of a haemodialysis machine using the Rodin toolset
Issues in Coordination Languages and Architectures
Core Hybrid Event-B II: Multiple cooperating Hybrid Event-B machines
Algebraic Specification and Verification of Communicating Protocols
Modules and transactions: Building blocks for a theory of software engineering
Model-checking processes with data
Approximating the Domains of Functional and Imperative Programs
Derivation of a Distributed Algorithm for Finding Paths in Directed Networks
Actionable code smell identification with fusion learning of metrics and semantics
Automatic generation of valid and invalid test data for string validation routines using web searches and regular expressions
High quality navigation in computer games
A lightweight API recommendation method for App development based on multi-objective evolutionary algorithm
CHOReVOLUTION: Service choreography in practice
Abstract State Machines, Alloy, B, TLA, VDM and Z (ABZ 2018)
A model-checker exploiting structural reductions even with stutter sensitive LTL
Efficient counter-factual type error debugging
Sound conformance testing for cyber-physical systems: Theory and implementation
From Informal Requirements to a Running Program: A Case Study in Algebraic Specification and Transformational Programming
A Heuristic Explanation of Batcher's Baffler
Reversible computation vs. reversibility in Petri nets
Evaluation of model transformation approaches for model refactoring
A program logic for fresh name generation
A clock-based dynamic logic for the verification of CCSL specifications in synchronous systems
A Hierarchy of Constraint Systems for Data-Flow Analysis of Constraint Logic-Based Languages
A logical characterization of differential privacy
An architecture for generic extensions
Automated compositional importance splitting
Model driven engineering of accessible and multi-platform graphical user interfaces by parameterized model transformations
Efficient virtual machine support of runtime structural reflection
Translating active objects into colored Petri nets for communication analysis
A tool chain for reverse engineering C++ applications
GREAT: UML transformation tool for porting middleware applications
A resource-efficient event algebra
Nested transactional memory: Model and architecture sketches
Simulation in Agent-Oriented Software Engineering: The SODA case study
Transformational Programming and the Paragraph Problem
Some trade-offs in reducing the overhead of assertion run-time checks via static analysis
Recovering memory access patterns of executable programs
Small Programming Exercises 7
Formal analysis of a calculus for WSNs from quality perspective
Domain-specific program profiling and its application to attribute grammars and term rewriting
PX-MBT: A framework for model-based player experience testing
Bootstrapping reflective systems: The case of Pharo
Bridging the gap between a behavioural formal description technique and a user interface description language: Enhancing ICO with a graphical user interface markup language
Baital: Sampling configurable systems with high t-wise coverage
ASM, controller synthesis, and complete refinement
Repository and meta-data design for efficient component consistency verification
Guest editorial to the special issue on Success Stories in Model Driven Engineering
Polytypic values possess polykinded types
Derivation of algorithmic control structures in Event-B refinement
LogLogics: A logic for history-dependent business processes
The universal resolving algorithm and its correctness: inverse computation in a functional language
Integrating SMT solvers in Rodin
Compositionality and correctness of fault tolerant patterns in HOL4
Dynamic state machines for modelling railway control systems
Ranking co-change candidates suggested by FLeCCS using programmer sensitivity
Local confluence analysis of hypergraph transformation systems with application conditions based on M-functors and Agg
Uncovering Architectural Mismatch in Component Behavior
An ML-style module system for cross-stage type abstraction in multi-stage programming
Pattern matching for the masses using custom notations
Compatibility and inheritance in software architectures
Axiomatizing CCS, Nets and Processes
Concurrency and synchronization in Java programs
Special issue on eLearning Software Architectures
Enforcing structural regularities in software using IntensiVE
Unrestricted and safe dynamic code evolution for Java
Formal modeling and analysis of railway operations with active objects
Simple section interchange and properties of non-computable functions
Selected papers of the Brazilian Symposium on Programming Languages 2014 (SBLP'14)
Designing for user attention: A method for supporting unobtrusive routine tasks
A guide to agile development of interactive software with a "User Objectives"-driven methodology
Simple and safe SQL queries with C++ templates
Evaluating a graphical notation for modeling collaborative learning activities: A family of experiments
Fault-Tolerant Broadcasts
Mobile JikesRVM: A framework to support transparent Java thread migration
Mathematics of Program Construction
Small Programming Exercises 3
Preface to the special section on Software Engineering Aspects of Ubiquitous Computing and Ambient Intelligence (UCAmI 2011)
Evolutionary design of user interfaces for workflow information systems
Choreography Realizability Enforcement through the Automatic Synthesis of Distributed Coordination Delegates
On methodology of representing knowledge in dynamic domains
EventML: Specification, verification, and implementation of crash-tolerant state machine replication systems
Transformational Design and Implementation of a New Efficient Solution to the Ready Simulation Problem
Solving games: Dependence of applicable solving procedures
On the introduction of density in tuple-space coordination languages
The Esterel Synchronous Programming Language: Design, Semantics, Implementation
A simple framework for real-time cryptographic protocol analysis with compositional proof rules
Mathematics for reasoning about loop functions
Symbolic Execution: A Semantic Approach
Applying model-driven engineering in small software enterprises
DevReplay: Linter that generates regular expressions for repeating code changes
Dependence analysis for safe futures
Specifying the Caltech Asynchronous Microprocessor
Preface to Rewriting Logic and Its Applications (extended selected papers from WRLA 2012)
Preface for the Special Issue on SBST'22: Search-Based Software Testing - Tools
Oberon-0 in Kiama
Constraint-Based Protocols for Distributed Problem Solving
The CLEARSY safety platform: 5 years of research, development and deployment
The role of supervisory controller synthesis in automatic control software development
Semantics, distributed implementation, and formal analysis of KLAIM models in Maude
Coordination models, languages and applications
Elementary Data Structures in ALGOL-Like Languages
An aspect-oriented model-driven approach for building adaptable context-aware service-based applications
Attribute grammar macros
Inferring software behavioral models with MapReduce
QoS contract preservation through dynamic reconfiguration: A formal semantics approach
Obituary: Professor Nobuo Yoneda (28 March 1930-22 April 1996)
New degrees of freedom in metaheuristic optimization of component-based systems architecture: Architecture topology and load balancing
Proofs of randomized algorithms in Coq
On competitive self-composition in pervasive services
BURST: Benchmarking uniform random sampling techniques
Delegation by object composition
Automatic syntax error reporting and recovery in parsing expression grammars
Elsevier special issue on foundations and applications of model driven architecture
Analyzing the performance of two COSMIC approximation sizing techniques at the functional process level
Mechanical verification of Lamport's Bakery algorithm
Evaluating the performance of architectures in MASCOT
Modeling and verifying the topology discovery mechanism of OpenFlow controllers in software-defined networks using process algebra
Preface to the special issue on Numerical Software: Design, Analysis and Verification
Model checking linear temporal logic of rewriting formulas under localized fairness
Effect capabilities for Haskell: Taming effect interference in monadic programming
Mathematics of Program Construction (selected papers from MPC 2010)
Monitoring and forecasting usability indicators: A business intelligence approach for leveraging user-centered evaluation data
Automated mass maintenance of a software portfolio
API recommendation for the development of Android App features based on the knowledge mined from App stores
A big step from finite to infinite computations
Synthesis of Reo circuits from scenario-based interaction specifications
The correctness of event-B inductive convergence
Software language engineering (SLE '12)
Trace semantics and refinement patterns for real-time properties in event-B models
Verification of the functional behavior of a floating-point program: An industrial case study
Point-free Substitution
Synchronous set relations in rewriting logic
Using heuristics to estimate an appropriate number of latent topics in source code analysis
Translating essential OCL invariants to nested graph constraints for generating instances of meta-models
Sourcerer: An infrastructure for large-scale collection and analysis of open-source code
FAMe-TM: Formal analysis methodology for task migration algorithms in Many-Core systems
Understanding probabilistic software leaks
Multiparty Negotiation of Dynamic Distributed Object Services
Exclusion requirements and potential concurrency for composite objects
ASP fun : A typed functional active object calculus
On Regularity in Software Design
B model quality assessments on automated reachability repair with ISO/IEC 25010
Generic tools for verifying concurrent systems
Probabilistic Models for the Guarded Command Language
Comparing differentiable logics for learning with logical constraints
Runtime monitoring of complex scenario-based requirements for autonomous driving functions
Studying software evolution using topic models
A new roadmap for linking theories of programming and its applications on GCL and CSP
PSTMonitor: Monitor synthesis from probabilistic session types
Towards naturalistic programming: Mapping language-independent requirements to constrained language specifications
Automated verification of shape, size and bag properties via user-defined predicates in separation logic
Behavioural theory of reflective algorithms I: Reflective sequential algorithms
Verification of the European Rail Traffic Management System in Real-Time Maude
PolyGloT: A personalized and gamified eTutoring system for learning modelling and programming skills
Jaccie: A Java-based compiler-compiler for generating, visualizing and debugging compiler components
A type-theoretic interpretation of pointcuts and advice
Remote attestation on legacy operating systems with trusted platform modules
Does the compiler or interpreter version influence the energy consumption of programming languages?
Predicting the maintainability of XSL transformations
Preface for the special issue of the 8th Conference on Reversible Computation (RC 2016)
MeTAGeM-Trace: Improving trace generation in model transformation by leveraging the role of transformation models
Graph neural network-based long method and blob code smell detection
Quantifying the value of IT-investments
Comparing three coordination models: Reo, ARC, and PBRD
Java heap protection for debugging native methods
Calculating Path Algorithms
Refactoring pattern matching
PPPJ special issue-Foreword
Exceptions Considered Harmless
Operational Semantics and Generalized Weakest Preconditions
Core Hybrid Event-B III: Fundamentals of a reasoning framework
Exploratory study on the syntactic and semantic consistency of terms in project management glossaries to provide recommendations for a project management ontology
Small Programming Exercises 23
Formal Aspects of Component Software (FACS'09)
Designing a verifying compiler: Lessons learned from developing Whiley
Rotations in the plane and Prolog
Fundamentals of Software Engineering (extended versions of selected papers of FSEN 2015)
A refinement development approach for enhancing the safety of PLC programs with Event-B
EVL: A framework for multi-methods in C++
A Comparison of Imperative and Purely Functional Suffix Tree Constructions
Invariant-driven specifications in Maude
GLL parse-tree generation
rbFeatures: Feature-oriented programming with Ruby
Moving in a network under random failures: A complexity analysis
ISTA+: Test case generation and optimization for intelligent systems based on coverage analysis
XGLR - an algorithm for ambiguity in programming languages
LayoutOptimizer: A layout rendering performance optimizer for Android application
Prescriptive procedure for manual code smell annotation
Real-time verification of wireless home networks using bigraphs with sharing
Statecharts: A Visual Formalism for Complex Systems
Exact and fully symbolic verification of linear hybrid automata with large discrete state spaces
On numerical regularity of the face-to-face longest-edge bisection algorithm for tetrahedral partitions
Analysis of three hybrid systems in timed µCRL
The orchestrator's partner management framework for software ecosystems
Component adaptation through flexible subservicing
Preface to the Special Issue on Object-Oriented Programming Languages and Systems (OOPS 2008), A Special Track at the 23rd ACM Symposium on Applied Computing
Slicing for architectural analysis
An Exercise in the Transformational Derivation of an Efficient Program by Joing Development of Control and Data Structure
Correctness of Transformations on Register Transfers
Preface: Selected papers from the Brazilian Symposium on Formal Methods (SBMF 2008)
Complete assertional proof rules for progress under weak and strong fairness
SAT-based verification for timed component connectors
Formal design of dynamic reconfiguration protocol for cloud applications
Calculational Derivation of Pointer Algorithms from Tree Operations
Exploiting semantic technologies in smart environments and grids: Emerging roles and case studies
Abstract Interpretation Using Typed Decision Graphs
Understanding information update in questionnaires
Variability management with feature models
A study of mutable checkpointing and related algorithms
Testing and incremental conformance testing of timed state machines
Evaluation and assessment of machine learning based user story grouping: A framework and empirical studies
Using formal methods to develop WS-BPEL applications
The Sensemaking-Coevolution-Implementation Theory of software design
Analyzing a wind turbine system: From simulation to formal verification
Transformation techniques for OCL constraints
Hubs for VirtuosoNext: Online verification of real-time coordinators
Deriving real-time action systems with multiple time bands using algebraic reasoning
Software product lines (SPLC 2010)
GXL: A graph-based standard exchange format for reengineering
Software architecture for integration of institutional and social learning environments
Reducing resource consumption of expandable collections: The Pharo case
Towards optimal solutions for the low power hard real-time task allocation on multiple heterogeneous processors
A formal model for service-oriented interactions
Studying software evolution using artefacts' shared information content
A practical comparator of cost functions and its applications
Checking business process evolution
AnimUML: A practical tool for partial model animation and analysis
Using eternity variables to specify and prove a serializable database interface
A monadic semantics for quantum computing in an object oriented language
Efficient algorithms for program equivalence for confluent concurrent constraint programming
Formal verification of side-channel countermeasures using self-composition
Timed Rebeca schedulability and deadlock freedom analysis using bounded floating time transition system
Typechecking protocols with Mungo and StMungo: A session type toolchain for Java
Fuzzing microservices: A series of user studies in industry on industrial systems with EvoMaster
Architectural styles for active documents
A component-based framework for certification of components in a cloud of HPC services
Left recursion in Parsing Expression Grammars
An Implementation of an Efficient Algorithm for Bisimulation Equivalence
Revising basic theorem proving algorithms to cope with the logic of partial functions
Formalizing the dependency pair criterion for innermost termination
Exceptions and Interrupts in CSP
XACML2mCRL2: Automatic transformation of XACML policies into mCRL2 specifications
A methodology for hardware verification using compositional model checking
Small Programming Exercises 18
A modeling approach for Systems-of-Systems by adapting ISO/IEC/IEEE 42010 Standard evaluated by Goal-Question-Metric
An expressive stateful aspect language
Enhancing software quality attributes through multi-dimensional refactoring at source-level
Event based choreography
A sound and complete theory of graph transformations for service programming with sessions and pipelines
Using MDA for integration of heterogeneous components in software supply chains
Refinement Principles Supporting the Transition from Asynchronous to Synchronous Communication
A new algorithm for the construction of minimal acyclic DFAs
Implementation of a Modelica compiler using JastAdd attribute grammars
Compositional assume-guarantee reasoning for input/output component theories
Optimal single-path information propagation in gradient-based algorithms
Theory-oriented software engineering
Locally weighted regression with different kernel smoothers for software effort estimation
A formal approach for the correct deployment of cloud applications
Towards a metrics suite for the complexity analysis of LabVIEW systems models
Supporting software composition at the programming language level
Using gate-level side channel parameters for formally analyzing vulnerabilities in integrated circuits
Bulterman's Reshuffling Problem
Mutating code annotations: An empirical evaluation on Java and C# programs
A method for identifying references between projects in GitHub
What business process modelers can learn from programmers
Approximately optimal facet value selection
Knowledge discovery in software teams by means of evolutionary visual software analytics
Validated evaluation of special mathematical functions
Automatic recursion engineering of reduction incorporated parsers
End-to-end information flow security for web services orchestration
Local reversibility in a Calculus of Covalent Bonding
Arbiters: An Exercise in Specifying and Decomposing Asynchronously Communicating Components
Extending UML sequence diagrams to model trust-dependent behavior with the aim to support risk analysis
Continuous quality assessment with inCode
BITAM: An engineering-principled method for managing misalignments between business and IT architectures
Modelling and analyzing adaptive self-assembly strategies with Maude
AmbieGen: A search-based framework for autonomous systems testing
Defining variability in activity diagrams and Petri nets
Preface for "Selected papers from the 25th Ibero-American Conference on Software Engineering (CIbSE 2022)"
Structural reconfiguration of systems under behavioral adaptation
Exploring issues of story-based effort estimation in Agile Software Development (ASD)
An adaptive pairwise testing algorithm based on deep reinforcement learning
Editorial (Selected Papers from the Third International Conference on the Mathematics of Program Construction)
Rankers: A Classification of Synchronization Problems
A framework for higher-order effects & handlers
Programming with exceptions in JCilk
Combining state- and event-based semantics to verify highly available applications
Automatic Analysis of Pointer Aliasing for Untyped Programs