yusuke1997/dblp-id-title huggingface dataset:
Automated verification of design patterns: A case study
Fast as a shadow, expressive as a tree: Optimized memory monitoring for C
Are you of value to me? A partner selection reference method for software ecosystem orchestrators
Formalisation and analysis of Dalvik bytecode
Reverse engineering is reverse forward engineering
Software verification with VeriFast: Industrial case studies
Algebraic Implementations Preserve Program Correctness
Formal Techniques for Safety-Critical Systems (FTSCS 2014)
Program Derivation Through Transformations: The Evolution of List-Copying Algorithms
Coverage testing of Java programs and components
Automatic deployment of component-based applications
Alternating-time stream logic for multi-agent systems
The java.util.concurrent synchronizer framework
Boolean constraints in SWI-Prolog: A comprehensive system description
Applying the Isabelle Insider framework to airplane security
Generic programming in 3D
Special issue on Automated Verification of Critical Systems (AVoCS'12)
A logic foundation for a general-purpose history querying tool
Educational and technical design of a Web-based interactive tutorial on programming in Java
Formally verifying consistency of sequence diagrams for safety critical systems
Parametric approach to the specification and analysis of real-time scheduling based on ACSR-VP
Specifications, Programs, and Total Correctness
Formal architecture modeling of sequential non-recursive C programs
Design patterns applied in the development of serious games for cognitive-affective training
Selected and extended papers of the Brazilian Symposium on Programming Languages 2012
Preface for the special issue of the 10th International Symposium on Theoretical Aspects of Software Engineering (TASE 2016)
Composing programming languages by combining action-semantics modules
Agent Coordination Contexts for the formal specification and enactment of coordination and security policies
Implementing advanced spoken dialogue management in Java
Efficient sessions
Checking global usage of resources handled with local policies
The Automated Transformation of Abstract Specifications of Numerical Algorithms into Efficient Array Processor Implementations
Region-Based RTSJ Memory Management: State of the art
Snapshots and software transactional memory
Model driven middleware: A new paradigm for developing distributed real-time and embedded systems
Process algebra with timing: J.C.M. Baeten and C.A. Middelburg (Eds); Springer, Berlin, 2002, pp. XX+287, ISBN 3-540-43447-X
Software architecture decision-making process: The practitioners' view from the Brazilian industry
Embedding Time Granularity in a Logical Specification Language for Synchronous Real-Time Systems
Alias calculus, change calculus and frame inference
Proof Rules and Transformations Dealing with Fairness
Applying large language models to issue classification: Revisiting with extended data and new models
A Derivation of a Serial-Parallel Multiplier
Proof assisted bounded and unbounded symbolic model checking of software and system models
Rewriting induction for constrained inequalities
A mechanical verification of the stressing algorithm for negative cost cycle detection in networks
Data Structures and Program Transformation
"Compositionality of projection inheritance" [Sci. Comput. Programming 42 (2-3) (2002) 129-171]
Special Section on Source Code Analysis and Manipulation (SCAM 2013)
Collaborative editing of EMF/Ecore meta-models and models: Conflict detection, reconciliation, and merging in DiCoMEF
A process calculus for Mobile Ad Hoc Networks
A risk analysis of disk backup or repository maintenance
Implementing type-safe software product lines using parametric traits
A hybrid approach to extract conceptual diagram from software requirements
State Space Reduction by Non-Standard Semantics for Deadlock Analysis
Finite subtype inference with explicit polymorphism
PAMELA: An annotation-based Java modeling framework
Verification of XTP Context Management Closing Procedure in Style of TLA
Mechanical incrementalization of typing algorithms
The CancerGrid experience: Metadata-based model-driven engineering for clinical trials
On the expressiveness of timed coordination models
The model transformation language of the VIATRA2 framework
NAT2TEST SCR : Test case generation from natural language requirements based on SCR specifications
Easy web service discovery: A query-by-example approach
"Your AI is impressive, but my code does not have any bugs" managing false positives in industrial contexts
Refunctionalization at work
Tri-modal under-approximation for test generation
Safety assessment of AltaRica models via symbolic model checking
Static safety guarantees for a low-level multithreaded language with regions
A domain-specific language for verifying software requirement constraints
Property specifications for workflow modelling
Experiences with an object-oriented, multi-stage language
TSC2CARLA: An abstract scenario-based verification toolchain for automated driving systems
PiXL: Applying xml standards to support the integration of analysis tools for protocols
Review: Practical Foundations of Mathematics - Paul Taylor, Cambridge Studies in Advanced Mathematics, Vol. 59, Cambridge University Press, Cambridge, 1999. xi+572 pages, price £50 paperback, ISBN 0-521-63107-6
A graph-based algorithm for three-way merging of ordered collections in EMF models
A Theoretical Basis for Stepwise Refinement and the Programming Calculus
Modeling and analysis of compositional software (papers from EUROMICRO SEAA'12)
Formal model-driven engineering of critical information systems
An Exercise in Program Synthesis: Algorithms for Computing the Transitive Closure of a Relation
Selected papers from the 15th international symposium on Theoretical Aspects of Software Engineering (TASE 2021)
Automated specification inference in a combined domain via user-defined predicates
A didactic object-oriented, prototype-based visual programming environment
Deriving Parallel Programs from specification Susing Cost Information
Preface for the special issue on tool papers of the 21st International Conference on Coordination Models and Languages, COORDINATION 2019
Executing Java programs with transactional memory
Next generation system and software architectures: Challenges from future NASA exploration missions
The Process Enactment Tool Framework - Transformation of software process models to prepare enactment
Lending Petri nets
Integrated program debugging, verification, and optimization using abstract interpretation (and the Ciao system preprocessor)
Exploring the frequency and change proneness of dynamic feature pattern instances in PHP applications
An exploratory study on the usage of quantum programming languages
Incremental design of statechart specifications
A Product Line engineering practices model
ScenarioTools - A tool suite for the scenario-based modeling and analysis of reactive systems
Google's MapReduce programming model - Revisited
Refinement of decomposed models by interface instantiation
A Case study in Model Checking Software Systems
Type-based termination of generic programs
Test case generation, selection and coverage from natural language
From CIL to Java bytecode: Semantics-based translation for static analysis leveraging
The Peer-Model tool-chain
Quantifying IT forecast quality
Algebras for correctness of sequential computations
Deriving real-time action systems in a sampling logic
Client-based cohesion metrics for Java programs
CAOVerif: An open-source deductive verification platform for cryptographic software implementations
Comparison of eigensolvers for symmetric band matrices
Extending the EB4EB framework with parameterised events
Selected and extended papers from Partial Evaluation and Program Manipulation 2014
Verification of concurrent code from synchronous specifications
Substitution: A Formal Methods Case Study Using Monads and Transformations
Certified control for train sign classification
Remembering Amir Pnueli, a great scientist and a great friend (April 22, 1941-November 2, 2009)
Weakest preconditions and cumulative subgoal fulfillment
Dynamic algorithm selection for runtime concepts
A calculus of program adaptation and its applications
A Simple Calculus for Program Transformation (Inclusive of Induction)
Supporting ATAM with a collaborative Web-based software architecture evaluation tool
Towards more adequate EIS
Type-2 effectivity in abstract state machines for algorithms with exact real arithmetic
GLL syntax analysers for EBNF grammars
Formal specification of MPI 2.0: Case study in specifying a practical concurrent programming API
ESBMC-GPU A context-bounded model checking tool to verify CUDA programs
Formal Techniques for Safety-Critical Systems (FTSCS 2015)
A family of heuristic search algorithms for feature model optimization
Small Programming Exercises 14
Implicit ownership types for memory management
Optimal Domains for Disjunctive Abstract Intepretation
Crawl-based analysis of web applications: Prospects and challenges
Program Derivation by Fixed Point Computation
A systematic mapping study on software product line evolution: From legacy system reengineering to product line refactoring
Verification of graph grammars using a logical approach
Comparing Integrated and External Logics of Functional Programs
Max-SAT-based synthesis of optimal and Nash equilibrium strategies for multi-agent systems
Towards proving type safety of .NET CIL
Behavioural contracts with request-response operations
Reasoning about logical systems in the Coq proof assistant
Guest editorial to the Special Issue on Component-Based Software Engineering and Software Architecture
Introduction to the TASE 2023 Special Issue
Combining preprocessor slicing with C/C++ language slicing
Versioned boxes as the basis for memory transactions
Dynamic state space partitioning for external memory state space exploration
Rule formats for determinism and idempotence
Strategies for Consistency Checking Based on Unification
A polynomial-time algorithm for global value numbering
Dynamic inference of polymorphic lock types
A case study on the lightweight verification of a multi-threaded task server
Profit-aware scheduling for time-sensitive applications in heterogeneous multi-server systems
AErlang: Empowering Erlang with attribute-based communication
Context-dependent product line engineering with lightweight formal approaches
Generating C: Heterogeneous metaprogramming system description
NOW: Orchestrating services in a nomadic network using a dedicated workflow language
BEAPI: A tool for bounded exhaustive input generation from APIs
Using source transformation to test and model check implicit-invocation systems
Towards a user-controlled software renovation factory
QueryAGT: Asynchronous global types in co-logic programming
Functional Programming with Side-Effects
Examining the performance of kernel methods for software defect prediction based on support vector machine
Metamorphisms: Streaming representation-changers
Object-focused environments revisited
Symbolic Evaluation with Structural Recursive Symbolic Constants
Abstraction models for verifying resource adequacy of IMA systems at concept level
Grid Protocols Based on Synchronous Communication
Goal-Directed Requirements Acquisition
Ambiguity and constrained polymorphism
Advances in Smalltalk technologies
An implementation framework for Software Architectures based on the coordination paradigm
A reconfigurable framework for compositional schedulability and power analysis of hierarchical scheduling systems with frequency scaling
Parallel execution of Java loops on Graphics Processing Units
Supporting Module Reuse in Refinement
Space consumption analysis by abstract interpretation: Reductivity properties
Using FDAF to bridge the gap between enterprise and software architectures for security
From tuple spaces to tuple centres
An effective software cross-project fault prediction model for quality improvement
EMIP: The eye movements in programming dataset
Session-ocaml: A session-based library with polarities and lenses
Design-code traceability recovery: selecting the basic linkage properties
Minimizing Characterizing sets
Model-driven development of interactive groupware systems: Integration into the software development process
Formal aspects of component software (FACS 2018)
Multi-paradigm Java-Prolog integration in tuProlog
Equational Reasoning in Isabelle
Model-based mutation testing - Approach and case studies
Towards Turing computability via coinduction
Formal verification of IoT applications using rewriting logic: An MDE-based approach
A Technique for Solving a Class of Puadratic FP Equations
Timed Rewriting Logic with an Application to Object-Based Specification
A debugging approach for live Big Data applications
An improved method for test case prioritization by incorporating historical test case data
Teaching Java programming with the Informa clicker system
Verifiable source code documentation in controlled natural language
Software development with Petri nets and agents: Approach, frameworks and tool set
ScriptEase: A generative/adaptive programming paradigm for game scripting
Space-efficient acyclicity constraints: A declarative pearl
A Case Study of Number-Theoretic Computation: Searching for Primes in Arithmetical Progression
Machine learning models for predicting software design effort
Quantifying the effects of IT-governance rules
System-level simulation-based verification of Autonomous Driving Systems with the VIVAS framework and CARLA simulator
Formal analysis of a hardware dynamic task dispatcher with CADP
The formalism underlying EASYMAP
Gaiwan: A size-polymorphic typesystem for GPU programs
Anemone: A workbench for the Multi-Bach coordination language
NeoEMF: A multi-database model persistence framework for very large models
A first-order language for expressing sharing and type properties of logic programs
Compact and efficient strings for Java
Improving Web Service descriptions for effective service discovery
Maximizing reachability probabilities in rectangular automata with random events
Combining sequential feature test cases to generate sound tests for concurrent features
The syntax and semantics of a domain-specific language for flow-network design
A formal approach for managing component-based architecture evolution
Software chrestomathies
An integrated framework for adapting WS-BPEL scenario execution using QoS and collaborative filtering techniques
Symbolic model checking for channel-based component connectors
Computing with Continuous Change
jcolibri2: A framework for building Case-based reasoning systems
What makes a real change in software performance? An empirical study on analyzing the factors that affect the triagement of performance change points
Specification of paraconsistent transition systems, revisited
Reductivity
Access-based abstract memory localization in static analysis
Reusing metadata across components, applications, and languages
Evaluating the effectiveness of size-limited execution trace with near-omniscient debugging
Compositional workflow modeling with priority constraints
A framework for automated conflict detection and resolution in medical guidelines
Formal verification of programs specified with signal: application to a power transformer station controller
Dynamic adaptation with distributed control in Paradigm
Ontology-driven middleware for next-generation train backbones
Improving custom-tailored variability mining using outlier and cluster detection
Extending a model-driven cross-platform development approach for business apps
Dependency safety for Java - Implementing and testing failboxes
Deriving a complete type inference for Hindley-Milner and vector sizes using expansion
Preface for the special issue on SBFT'23: Search-Based and Fuzz Testing - Tools
ATL: A model transformation tool
Preface: Special issue on Foundations of Coordination Languages and Software Architectures (selected papers from FOCLASA'09)
A Note on a Standard Strategy for Developing Loop Invariants and Loops
Semantics-based generation of verification conditions via program specialization
On the value of project productivity for early effort estimation
A Configurable Software Model of a Self-Adaptive Robotic System
Generation of components for software renovation factories from context-free grammars
Mechanization of coherence and adequacy: Being extrinsic extended to subtyping
Modeling variability in software product lines with the variation point model
The formalization and implementation of Adaptable Parsing Expression Grammars
Building augmented reality games with
A semantic analysis of key management protocols for wireless sensor networks
Formal Techniques for Safety-Critical Systems (FTSCS 2016)
Profiles in a strict metamodeling framework
A systematic literature review on dynamic testing of blockchain oriented software
API comparison based on the non-functional information mined from Stack Overflow
Using a trope-based foundational ontology for bridging different areas of concern in ontology-driven conceptual modeling
A New Programming Technique for Lazy Functional Languages
Mi Superpoder es la Programación: A tool for teaching programming to children and youth
Small Programming Exercises 16
Improving time bounded reachability computations in interactive Markov chains
Quality system and software architectures
Five perspectives on modern memory management: Systems, hardware and theory
Supporting Contexts in Program Refinement
An ontology-based approach for integrating tools supporting the software measurement process
Principles and Practice of Programming in Java 2008 - Special issue
Asynchronous synthesis techniques for coordinating autonomic managers in the cloud
Static Typing for Object-Oriented Programming
Narrowing and heuristic search for symbolic reachability analysis of concurrent object-oriented systems
Special Issue on Formal Aspects of Component Software (Selected Papers from FACS'12)
Bridging the Algorithm Gap: A Linear-Time Functional Program for Paragraph Formatting
On the verification of SCOOP programs
Decoding techniques applied to the compilation of CNOT circuits for NISQ architectures
Specifying safety-critical systems with a decidable duration logic
Global consensus through local synchronization: A formal basis for partially-distributed coordination
An algorithm for compositional nonblocking verification using special events
Theory propagation and reification
Special issue on Service-Oriented Architecture and Programming (SOAP 2013)
Optimizing SYB traversals is easy!
Lightweight energy consumption analysis and prediction for Android applications
Exception analysis in the Java Native Interface
The early bird catches the worm: First verify, then monitor!
DREMS ML: A wide spectrum architecture design language for distributed computing platforms
Expressing aspectual interactions in requirements engineering: Experiences, problems and solutions
Test-data generation directed by program path coverage through imperialist competitive algorithm
Preface to Special issue with extended selected papers from FACS 2015
MetaOCaml: ten years later - System description
A transactional object calculus
Supporting automated containment checking of software behavioural models using model transformations and model checking
Filling query-type text inputs for Android applications via inner-app mining and GPT recommendation
Mechanical reasoning about families of UTP theories
Guest editors' introduction to the fifth issue of Experimental Software and Toolkits (EST): A special issue on Academics Modelling with Eclipse (ACME2012)
Preface for "Quantum Programming for Software Engineering (QP4SE)"
Extraction of domain concepts from the source code
Gamifying model-based engineering: The PapyGame tool
Coordination in Socio-technical Systems: Where are we now? Where do we go next?
A General Incremental Evaluator for Attribute Grammars
Knowledge representation and information extraction for analysing architectural patterns
An analysis of unit tests of a flight software product line
Constructive Consistency Checking for Partial Specification in Z
Developing topology discovery in Event-B
simpA: An agent-oriented approach for programming concurrent applications on top of Java
Solving the Linda Multiple rd Problem Using the Copy-Collect Primitive
Deductive verification of solidity smart contracts with SSCalc
On Euclid's algorithm and elementary number theory
Rule-based modularization in model transformation languages illustrated with ATL
Developing correct, distributed, adaptive software
A meta-theory for component interfaces with contracts on ports
Refining a design thinking-based requirements elicitation process: Insights from a focus group
A Scientific Workflow Management System for orchestration of parallel components in a cloud of large-scale parallel processing services
Lawful Functions and Program Verification in Miranda
Computation calculus bridging a formalization gap
Relational symbolic execution of SQL code for unit testing of database programs
Brazilian Symposium on Programming Languages (SBLP 2011)
A Haskell-embedded DSL for secure information-flow
Source-code queries with graph databases - with application to programming language usage and evolution
The metafront system: Safe and extensible parsing and transformation
A rewriting logic approach to resource allocation analysis in business process models
Extending standard UML with model composition semantics
Automatic parallelization of recursive functions with rewriting rules
Selected papers on Integrated Formal Methods (iFM09)
MetaOCaml server pages: Web publishing as staged computation
A form-based meta-model for software composition
PomCho: A tool chain for choreographic design
Modular type checking of anchored exception declarations
Handles: Behavior-propagating first class references for dynamically-typed languages
Small Programming Exercises 19
The complexity of evaluating nfer
Integrating formal methods into medical software development: The ASM approach
Static analysis of real-time component-based systems configurations
Stratified sampling of execution traces: Execution phases serving as strata
The SGSM framework: Enabling the specification and monitor synthesis of safe driving properties through scene graphs
Editorial - Theoretical Aspects of Software Engineering (2017)
Special issue on synchronization and concurrency in object-oriented languages
The Smallest Upravel
Unifying design and runtime software adaptation using aspect models
Investigating quality aspects for UX evaluation of IoT-based applications in smart cities: A literature review
Implementability of requirements in the four-variable model
Abstracting cryptographic protocols with tree automata
Encoding TLA+ proof obligations safely for SMT
An experimental ambiguity detection tool
Fundamentals of software engineering (selected papers of FSEN '09)
Preface - Selected papers from the 23rd Brazilian Symposium on Formal Methods - SBMF 2020
Comparing coordination models and architectures using embeddings
Adding mobility to software architectures
Preface to the Special section on Self-Organizing Coordination
Distributed constraint optimisation for resource limited sensor networks
Engineering and theoretical underpinnings of retrenchment
Modeling dynamic reconfigurations in Reo using high-level replacement systems
Tackling rapid technology changes by applying enterprise engineering theories
Improving software effort estimation using bio-inspired algorithms to select relevant features: An empirical study
Deciding conformance for bounded responsiveness
Computer-assisted verification of a protocol for certified email
Transparent replication using metaprogramming in Cyan
Selected papers from the Rigorous State-Based Methods, 7th International Conference, ABZ 2023, Nancy, France, May 30-June 2, 2023
Editorial comment to 'About "trivial" software patents: The IsNot case'
FSM quasi-equivalence testing via reduction and observing absences
The optics of language-integrated query
A comparison of abstract data types and objects recovery techniques
Randomised testing of a microprocessor model using SMT-solver state generation
Formal specification of multi-agent e-barter systems
Intrathread method orders based adaptive testing of concurrent objects
Program verification via iterated specialization