yusuke1997/dblp-id-title huggingface dataset:
Grits: A message-passing programming language based on the semi-axiomatic sequent calculus
The MATLAB Toolbox for EnergyPLAN: A tool to extend energy planning studies
On the semantics and implementation of replicated data types
Guest editor's introduction: Second issue of experimental software and toolkits (EST)
MobiLine: A Nested Software Product Line for the domain of mobile and context-aware applications
A unified view of monadic and applicative non-determinism
Formal security analysis for software architecture design: An expressive framework to emerging architectural styles
Providing data confidentiality against malicious hosts in Shared Data Spaces
Functional Documents for Computer Systems
Modelling, formal refinement and partitioning strategies for a small aircraft fuel pump system in Hybrid Event-B
JBInsTrace: A tracer of Java and JRE classes at basic-block granularity by dynamically instrumenting bytecode
Modal event-clock specifications for timed component-based design
Proving Properties of Real-Time Semaphores
Reuse estimate and interval prediction using MOGA-NN and RBF-NN in the functional paradigm
Prioritizing versions for performance regression testing: The Pharo case
Automatically refining partial specifications for heap-manipulating programs
Synchronous Programming with Events and Relations: the SIGNAL Language and Its Semantics
Two approaches for proving linearizability of multiset
Metric information mining with metric attention to boost software defect prediction performance
Aspects of availability: Enforcing timed properties to prevent denial of service
Strengthening invariants for efficient computation
MDAPW3: MDA-based development of blockchain-enabled decentralized applications
Preface - Invariant Generation
Preface to the special section on agent-oriented design methods and programming techniques for distributed computing in dynamic and complex environments
Some Algorithms Based on the Dual of Dilworth's Theorem
Preface of Special issue on Automated Verification of Critical Systems (AVoCS'14)
On modelling and verifying railway interlockings: Tracking train lengths
Distributed and Collaborative Software Evolution Analysis with Churrasco
High-level axioms for graphical linear algebra
A change impact model for changeability assessment in object-oriented software systems
Emulating C++0x concepts
Scoping strategies for distributed aspects
Laura - A Service-Based Coordination Language
Automatically verifying an object-oriented specification of the Steam-Boiler system
Preface to the special section on software evolution, adaptability, and maintenance
Modular architecture for a toolset supporting OCL
Predicate Transformers for Reasoning about Concurrent Computation
Characterization of continuous experimentation in software engineering: Expressions, models, and strategies
Partially defined computer instructions and guards
Type error slicing in implicitly typed higher-order languages
Automatic detection of infeasible paths in large-scale program based on program summaries
Quantifying the yield of risk-bearing IT-portfolios
A Higher-Order Implementation of Rewriting
Open source software and the algorithm visualization community
Small Programming Exercises 22
yRCA: An explainable failure root cause analyser
Robust trait composition for Javascript
Salespoint: A Java framework for teaching object-oriented software development
A portable virtual machine target for proof-carrying code
Software engineering: Redundancy is key
"Will I be replaced?" Assessing ChatGPT's effect on software development and programmer perceptions of AI tools
Preface to the special issue on Coordination Models and Languages (Coordination 2017)
Supporting iterations in exploratory database reengineering processes
A perspective on architectural re-engineering
Pacta sunt servanda: Legal contracts in Stipula
Symbolic execution as a basis for termination analysis
The SPARTA pseudonym and authorization system
Runtime verification of microcontroller binary code
Sciit: Embedding issue tracking in source control management
Specification of temporal properties with OCL
Calculating with Pointers
USE: A UML-based specification environment for validating UML and OCL
Preface (Special Issue on Parallel Programming)
An update calculus for expressing type-safe program updates
Designing high quality system/software architectures
The CAOS framework for Scala: Computer-aided design of SOS
JoT: A Jolie framework for testing microservices
Concurrency and local reasoning under reverse exchange
Parallelism analysis: Precise WCET values for complex multi-core systems
Supporting simultaneous versions for software evolution assessment
Towards a comprehensive extension of abstract state machines for aspect-oriented specification
As-if-serial exception handling semantics for Java futures
Small Programming Exercises 9
Mining structured data in natural language artifacts with island parsing
Infeasible paths in object-oriented programs
The Small Project Observatory: Visualizing software ecosystems
Mining inline cache data to order inferred types in dynamic languages
Special issue on library-centric software design (LCSD 2006)
Reversing an imperative concurrent programming language
Simulation of multicellular populations with Petri nets and genome scale intracellular networks
Specifying embedded systems with statecharts and Z: an agenda for cyclic software components
Verification of forward simulations with thread-local, step-local proof obligations
TraLogAnomaly: A microservice system anomaly detection approach based on hybrid event sequences
Yield grammar analysis and product optimization in a domain-specific language for dynamic programming
Correctness of On-Line Partial Evaluation for a Pascal-Like Language
Agile effort estimation in Colombia: An assessment and opportunities for improvement
Partial redundancy elimination: a simple, pragmatic, and provably correct algorithm
Skew-space garbage collection
Step coverability algorithms for communicating systems
Array bounds check elimination in the context of deoptimization
Automatic concurrency in SequenceL
Parallel program analysis on path ranges
A type system for first-class layers with inheritance, subtyping, and swapping
Foreword: Special Issue on Mathematics of Program Construction
Proving partial-correctness and invariance properties of transition-system models
Approximate by thinning: Deriving fully polynomial-time approximation schemes
A Logic for a Coordination Model with Multiple Spaces
A formal model of data access for multicore architectures with multilevel caches
Arrays, Bounded Quantification and Iteration in Logic and Constraing Logic Programming
Developing a Linear Algorithm for Cubing a Cyclic Permutation
Selected papers from Mathematics of Program Construction 2012
A formal model of concurrent systems based on bipartite directed acyclic graph
Modeling and verification of real-time systems based on equations
Finding compact proofs for infinite-data parameterised Boolean equation systems
Dynamic program analysis - Reconciling developer productivity and tool performance
Many-to-many information flow policies
Sibilla: A tool for reasoning about collective systems
CD-Form: A clone detector based on formal methods
Special section on the Programming Languages track at the 26th ACM Symposium on Applied Computing
Designing runtime variation points in product line architectures: three cases
When intuition and logic clash: The case of the object-oriented paradigm
Type inference against races
Building CBR systems with jcolibri
Improving performance with hybrid feature selection and ensemble machine learning techniques for code smell detection
The humble humorous researcher: A tribute to Michel Sintzoff
Introduction to the special issue from Petri Nets 2016
Designing and managing evolving systems using a MAS product line approach
Polytypic data conversion programs
Letter from the editor
Compositional noninterference on hardware weak memory models
Small Programming Exercises 24
Enhancing test reuse with GUI events deduplication and adaptive semantic matching
A declarative enhancement of JavaScript programs by leveraging the Java metadata infrastructure
Special issue on programming based on actors, agents and decentralized control
The VariCity ecosystem: City visualization of object-oriented variability in Java and TypeScript
Rewriting of imperative programs into logical equations
Blackboard rules: From a declarative reading to its application for coordinating context-aware applications in mobile ad hoc networks
Improving Recursive Functions by Inverting the Order of Evaluation
A 'Division' Transformation for Program and Data Structures and the Structure Clash Problem
Model-based programming environments for spreadsheets
Guest editors' introduction to the 4th issue of Experimental Software and Toolkits (EST-4)
The (Algebraic) Congruence of Two Programming Language Definitions
Combining dynamic and static slicing for analysing assembler
Efficient Handling of Data Structures in Definitional Languages
A language for generic programming in the large
Modelling and verifying BDI agents under uncertainty
A practical solution for achieving language compatibility in scripting language compilers
Beyond Atomic Registers: Bounded Wait-Free Implementations of Nontrivial Objects
Formal verification of autonomous vehicle platooning
Cost-effective simulation-based test selection in self-driving cars software
Understanding database schema evolution: A case study
Comparing model checkers for timed UML activity diagrams
libmg: A Python library for programming graph neural networks in μG
Event-B formalisation of a chat system: A case study
An Industrial Application of Modal Process Logic
Automated model extraction: From non-deterministic C code to active objects
A zoom-declarative debugger for sequential Erlang programs
KALA: Kernel aspect language for advanced transactions
The Mathematical Construction of a Program
A methodological approach to the formal specification of real-time systems by transformation of UML-RT design models
Generating Data Flow Analysis Algorithms from Modal Specifications
A quantitative and qualitative assessment of aspectual feature modules for evolving software product lines
Combining range and inequality information for pointer disambiguation
Castor: Programming with extensible generative visitors
Refinement checking for privacy policies
Preface to the special section on Object-Oriented Programming and Systems (OOPS 2015)
From extended feature models to constraint logic programming
Feature integration using a feature construct
View-based axiomatic reasoning for the weak memory models PSO and SRA
Formal development of wireless sensor-actor networks
S2O: A smart objects orchestrator framework based on the web of things
Towards attack-resistant Aggregate Computing using trust mechanisms
Validating, verifying and testing timed data-flow reactive systems in Coq from controlled natural-language requirements
Preface to the special issue on Formal Methods: Foundations and Applications
Generic downwards accumulations
Stackability in the Simply-Typed Call-by-Value lambda Calculus
Combinators and type-driven transformers in Objective Caml
Update from the Editorial Team
An improved fault-tolerant routing algorithm for a Network-on-Chip derived with formal analysis
Automated replication of tuple spaces via static analysis
Integration testing of Object-Oriented and Aspect-Oriented programs: A structural pairwise approach for Java
Safe manual memory management in Cyclone
A lightweight deadlock analysis for programs with threads and reentrant locks
Notes on the maximality of reversible gate sets under borrow and ancilla closure
A theory of integrating tamper evidence with stabilization
A formal actor-based model for streaming the future
Constraint specialisation in Horn clause verification
An incremental algorithm to construct a lattice of set intersections
Structuring the GLL parsing algorithm for performance
Projecting programs on specifications: Definition and implications
Inclusion algorithms for one-unambiguous regular expressions and their applications
State identification for labeled transition systems with inputs and outputs
Dynamic configuration management in a graph-oriented Distributed Programming Environment
Higher-order logic programming: An expressive language for representing qualitative preferences
In the quantitative automata zoo
Chronos: A timing analyzer for embedded software
VisFork: Towards a toolsuite for visualizing fork ecosystems
A methodological approach for mobile applications development: MethApp4Mob
Rigi - An environment for software reverse engineering, exploration, visualization, and redocumentation
Increasing Modularity and Language-Independency in Automatically Generated Compilers
Distributed directory service and message routing for mobile agents
Selected papers from The 13th International Symposium on Theoretical Aspects of Software Engineering 29 July - 1 August 2019, Guilin, China
Mutable strings in Java: design, implementation and lightweight text-search algorithms
Compositional reasoning for weighted Markov decision processes
JCML: A specification language for the runtime verification of Java Card programs
Adaptation space exploration for service-oriented applications
Controller synthesis of service contracts with variability
Transformation of Polynomial Evaluation to a Pipeline via Horner's Rule
A framework for evolution of modelling languages
Preface: Fundamentals of Software Engineering (extended versions of selected papers of FSEN 2023)
Special issue on revised and extended versions of papers presented at the 22nd Brazilian Symposium on Programming Languages (SBLP 2018)
Creating and reconciling diagrams after executing model transformations
Modeling web applications infrastructure with ASMs
Understanding software through linguistic abstraction
Selected papers from the Brazilian Symposiums on Formal Methods (SBMF 2012 and 2013)
How accessibility affects other quality attributes of software? A case study of GitHub
Comprehensive aspect weaving for Java
I Was a Computer
Remodularizing Java programs for improved locality of feature implementations in source code
Terms with unbounded demonic and angelic nondeterminacy
Preface for selected and extended papers from Principles and Practice of Declarative Programming (PPDP'15)
Automated amortised resource analysis for term rewrite systems
Costing parallel programs as a function of shapes
Synthesizing and integrating legacy components as services using adapters
How the design of JML accommodates both runtime assertion checking and formal verification
Guest editors' introduction to the first issue on Experimental Software Engineering in the Cloud (ESEiC)
Sequential and distributed on-the-fly computation of weak tau-confluence
Parameterized, concurrent session types for asynchronous multi-actor interactions
Synthesis of a New Systolic Architecture for the Algebraic Path Problem
A source of inconsistency in theories of nondeterministic functions
Applications of a Strategy for Designing Divide-and-Conquer Algorithms
A New Approach to Earley's Parsing Algorithm
SWQL: A new domain-specific language for mining the social Web
Automation and consistency analysis of test cases written in natural language: An industrial context
A Taxonomy of Sublinear Multiple Keyword Pattern Matching Algorithms
Counterexample guided inductive optimization based on satisfiability modulo theories
Enabling declarative security through the use of Java Data Objects
Special issue on selected papers from the 14th International Conference on Formal Aspects of Component Software (FACS 2017)
The ABS simulator toolchain
Extending type systems in a library: Type-safe XML processing in C++
Generative software complexity and software understanding
A framework for defining coupling metrics
Sustaining and improving graduated graph consistency: A static analysis of graph transformations
The Package Blueprint: Visually analyzing and quantifying packages dependencies
A tutorial on metamodelling for grammar researchers
Using classic problems to teach Java framework design
Self-healing components in robust software architecture for concurrent and distributed systems
Coordinating processes with secure spaces
Special Issue on Software Maintenance Tools at 35th International Conference on Software Maintenance and Evolution (ICSME 2019)
Modeling mobile stateful channels in π πZ
Verification of message-passing uninterpreted programs
Recognition is not parsing - SPPF-style parsing from cubic recognisers
A clock-based dynamic logic for schedulability analysis of CCSL specifications
Using semi-formal methods for detecting interactions among smart homes policies
Disciplined structured communications with disciplined runtime adaptation
On the use of feature-oriented programming for evolving software product lines - A comparative study
Formal Aspects of Component Software (FACS 2013)
Identifier length and limited programmer memory
Definition and use of Computation Independent Models in an MDA-based groupware development process
Lock-free parallel and concurrent garbage collection by mark&sweep
An algebraic foundation for automatic feature-based program synthesis
Mediator : A component-based modeling language for concurrent and distributed systems
On the verification of mission-related properties in software-intensive systems-of-systems architectural design
Optimizing generated aspect-oriented assertion checking code for JML using program transformations: An empirical study
Abstracting gradual references
Linearisation: An Optimisation for Nonlinear Functional Programs
From Flow Logic to static type systems for coordination languages
Verifying Programs That Use Causally-Ordered Message-Passing
On probabilistic term rewriting
Erratum to "Book review: Process algebra with timing" [Sci. Comput. Programming 51 (2004)291-292]
A Refinement Calculus for Tuple Spaces
Model of Error Propagation in Systems of Communicating Processes
RRPlib: A spark library for representing HDFS blocks as a set of random sample data blocks
Robustness and closure properties of recognizable languages in adhesive categories
Guest editors' introduction to the 6th issue of Experimental Software and Toolkits (EST-6)
Orchestrating incomplete TOSCA applications with Docker
Preface to the special issue on Formal Methods for Industrial Critical Systems (FMICS'2014)
Model transformations in MT
On the integration of Smalltalk and Java
A logic for reflective ASMs
Viewing functions as token sequences to highlight similarities in source code
Stochastic analysis of BPMN with time in rewriting logic
Composing invariants
A discipline of dynamic programming over sequence data
Preface to the Special Section on Language Descriptions, Tools, and Applications (LDTA 2011)
Register allocation by proof transformation
Convergence of program transformers in the metric space of trees
Contextual abstraction in a type system for component-based high performance computing platforms
Optimization of Farkas' Lemma-based linear invariant generation using divide-and-conquer with pruning
Extensible intraprocedural flow analysis at the abstract syntax tree level
A method of test case set generation in the commutativity test of reduce functions
Modelling and model checking suspendible business processes via statechart diagrams and CSP
A linear type system for multicore programming in ATS
A lightweight and distributed middleware to provide presence awareness in mobile ubiquitous systems
Description and Improvement of Iterative Program Transformations
Use-case components for interactive information systems
Garbage collection: Java application servers' Achilles heel
Derivation of Concurrent Programs: Two Examples
Variability abstractions for lifted analyses
Gaussian Elimination: A case study in efficient genericity with MetaOCaml
Lazy Type Inference and Program Analysis
Synthesis of hierarchical systems
Automatic Autoprojection of Recursive Equations with Global Variables and Abstract Data Types
Preface for the special issue on Software Development Concerns in the e-Learning Domain
Selected papers from the 2021 European Conference on Object-Oriented Programming
SBD: Securing safe rust automatically from unsafe rust
Abstract State Machines, Alloy, B and Z Selected papers from ABZ 2010
Model checking of concurrent programs with static analysis of field accesses
An old new notation for elementary probability theory
Comparative Semantics for PROLOG with Cut
Foreword: Selected Papers of ESOP'92
Preface of Automated Verification of Critical Systems 2010 (AVoCS 2010)
Provably correct implementation of the AbC calculus
Contract Automata Library
Towards base rates in software analytics: Early results and challenges from studying Ohloh
Core Hybrid Event-B I: Single Hybrid Event-B machines
Exceptions and side-effects in atomic blocks
Specifying Concurrent Objects as Communicating Processes
Function extraction
Formal modelling and verification of interlocking systems featuring sequential release
Report on the Larch Shared Language
Quantitative IT portfolio management
Towards multilingual programming environments
Local deadlock analysis of Simulink models based on timed behavioural patterns and theorem proving
Error reporting in Parsing Expression Grammars
Formal Derivation of a Pattern Matching Algorithm
Symbolic Techniques for Formally Verifying Industrial Systems
Adaptability checking in complex systems
Trusta: Reasoning about assurance cases with formal methods and large language models
A procedure for splitting data-aware processes and its application to coordination
Special issue on software clones (IWSC'12)
Preface to the special issue on Formal Methods for Industrial Critical Systems (FMICS 2007 + FMICS 2008)
Sequences as a basis for pattern language composition
Design-time product line architectures for any-time variability
A machine-checked correctness proof for Pastry
Design and Analysis of Up-Down Counters
Linear combinations of radioactive decay models for generational garbage collection
Observations on the assured evolution of concurrent Java programs
Fundamentals of Software Engineering (extended versions of selected papers of FSEN 2021)
Extracting Java library subsets for deployment on embedded systems
Qualification of proof assistants, checkers, and generators: Where are we and what next?
TextFlows: A visual programming platform for text mining and natural language processing
XVCL: a mechanism for handling variants in software product lines
Reasoning about connectors using Coq and Z3
Transformation of structure-shy programs with application to XPath queries and strategic functions
All roads lead to Rome: Commuting strategies for product-line reliability analysis
An application-level technique based on recursive hierarchical state machines for agent execution state capture
GraphPyRec: A novel graph-based approach for fine-grained Python code recommendation
CenUMs - concurrency enhanced usage models for statistical testing of complex systems with concurrent streams of use
Toward mobile entertainment: A paradigm for narrative-based audio only games
PANTHER: Pluginizable testing environment for network protocols
On the theory of system administration
Specification and verification of GPGPU programs
Software evolutionary architecture: Automated planning for functional changes
The automation of design model repair
Observations on formal safety analysis in practice
Finite complete suites for CSP refinement testing
Generalising tree traversals and tree transformations to DAGs: Exploiting sharing without the pain
Modelling Jackson's Programming Method
Parsing for agile modeling
Real-Time Specification and Modeling with Joint Actions
Charting AI urbanism: conceptual sources and spatial implications of urban artificial intelligence
Diagnosis of steam turbine rotor based on improved convolutional neural network algorithm
Artificial intelligence approach to intrusion detection in industrial control systems with real world dataset generation and model evaluation
Harnessing AI for smart manufacturing: insights from Industry 4.0
A CNN-transformer framework for emotion recognition in code-mixed English-Hindi data
AI-powered smart hydrological measurement using deep vision integrated with BeiDou high precision positioning