yusuke1997/dblp-id-title huggingface dataset:
Proceedings of the workshop on ACadeMics Tooling with Eclipse, ACME@ECOOP 2013, Montpellier, France, July 2, 2013
Semantic Models for Distributed Object Reflection
Experiences Developing a Virtual Shared Memory System Using High-Level Object Paradigms
Static Type Analysis by Abstract Interpretation of Python Programs
Chain of Grounded Objectives: Concise Goal-Oriented Prompting for Code Generation
A sip of the Chalice
Context-oriented programming with EventJava
Detecting Missing Method Calls in Object-Oriented Software
Adaptive Context-sensitive Analysis for JavaScript
Ownership Domains: Separating Aliasing Policy from Mechanism
Concurrent Cycle Collection in Reference Counted Systems
36th European Conference on Object-Oriented Programming, ECOOP 2022, Berlin, Germany, June 6-10, 2022
COP@ECOOP 2022: International Workshop on Context-Oriented Programming and Advanced Modularity (collocated with ECOOP), Berlin, Germany, 7 June 2022
The Eureka Programming Model for Speculative Task Parallelism
DirectFlow: A Domain-Specific Language for Information-Flow Systems
Zone-based Layer Activation: Context-specific Behavior Adaptations across Logically-connected Asynchronous Operations
ACadeMics tooling with Eclipse: ACME 2013 workshop summmary
An Empirical Study on Deoptimization in the Graal Compiler
ConSysT: tunable, safe consistency meets object-oriented programming
35th European Conference on Object-Oriented Programming, ECOOP 2021, Aarhus, Denmark (Virtual Conference), July 11-17, 2021
Data Exploration through Dot-driven Development
Push-based reactive layer activation in context-oriented programming
Foundations of object-based concurrent programming (panel session)
Ownership-Based Isolation for Concurrent Actors on Multi-core Machines
Expressiveness, Simplicity, and Users
ObjChart: Tangible Specification of Reactive Object Behavior
Modular Compilation for Higher-Order Functional Choreographies
Proceedings of the Workshop on Programming Models and Languages for Distributed Computing, Barcelona, Spain, June 20, 2017
Modular Software Upgrades for Distributed Systems
On Variance-Based Subtyping for Parametric Types
Wringing out objects for programming and modeling component-based systems
The Continuing Quest for Abstraction
Product Configurations - An Application for Prototype Object Approach
Reducing Lookups for Invariant Checking
Multiparty Languages: The Choreographic and Multitier Cases (Pearl)
Types, Regions, and Effects for Safe Programming with Object-Oriented Parallel Frameworks
Learning Gradual Typing Performance
Blame for Null
Model-View-Update-Communicate: Session Types Meet the Elm Architecture
An approach to modular object-oriented programming in language-driven development framework
Staccato: A Bug Finder for Dynamic Configuration Updates
ChyPro: A Hypermedia Programming Environment for Smalltalk-80
An Object Calculus for Asynchronous Communication
Fine-Grained Access Control with Object-Sensitive Roles
RacerF: Lightweight Static Data Race Detection for C Code (Experience Paper)
Mailbox Types for Unordered Interactions
Constraints and Object Identity
Memory-safe Execution of C on a Java VM
What Object-Oriented Programming May Be - and What It Does Not Have To Be
Detecting unanticipated aspect interferences at runtime with compositional intentions
Efficiently Refactoring Java Applications to Use Generic Libraries
Cross-cutting Commentary: Narratives for Multi-party Mechanisms and Concerns
Contract Usage and Evolution in Android Mobile Applications
Demand-Driven Type Inference with Subgoal Pruning: Trading Precision for Scalability
Support for quality metrics in metamodelling
CoCo: Sound and Adaptive Replacement of Java Collections
ReCrash: Making Software Failures Reproducible by Preserving Object States
Object-oriented programming versus object-oriented design (keynote address): what's the connection?
Proceedings of the 12th Workshop on Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems, ICOOOLPS@ECOOP 2017, Barcelona, Spain, June 19, 2017
TinyCORP: A Calculus for Context-Oriented Reactive Programming
Static Analysis for AWS Best Practices in Python Code
Front Matter, Table of Contents, Preface, Artifacts, Conference Organization
Java is Type Safe - Probably
Position Paper: Feature Interaction in Composed Systems
Feature-Oriented Programming: A Fresh Look at Objects
Parallelizing Julia with a Non-Invasive DSL
Implementing Bounded Aspect Quantification in AspectJ
Static Deadlock Detection for Java Libraries
Modular Statically Typed Multimethods
Formalizing, Mechanizing, and Verifying Class-Based Refinement Types
Making an Embedded DBMS JIT-friendly
Space- and Time-Efficient Implementation of the Java Object Model
Static Analysis of Shape in TensorFlow Programs
ALPACAS: A Language for Parametric Assessment of Critical Architecture Safety
Integrating Subtyping, Matching and Type Quantification: A Practical Perspective
Nested Mixin-Methods in Agora
Programming Coordinated Behavior in Java
Actalk: A Testbed for Classifying and Designing Actor Languages in the Smalltalk-80 Environment
Runtime feedback in a meta-tracing JIT for efficient dynamic languages
A Deterministic Memory Allocator for Dynamic Symbolic Execution
The declarative nature of implicit layer activation
Correlation Tracking for Points-To Analysis of JavaScript
The Love/Hate Relationship with the C Preprocessor: An Interview Study
Improving the Tokenisation of Identifier Names
Towards safe and flexible object adaptation
Lightweight Session Programming in Scala
Self-Replicating Objects for Multicore Platforms
Pydrofoil: Accelerating Sail-Based Instruction Set Simulators
Targeted Test Generation for Actor Systems
Use Case Level Pointcuts
Proceedings of the MechAnisms on SPEcialization, Generalization and inHerItance, MASPEGHI@ECOOP 2015, Prague, Czech Republic, July 4-10, 2015
An Accidental Simula User
On the Potential of Event Sourcing for Retroactive Actor-based Programming
Understanding the dynamics of JavaScript
Object-Oriented Architectural Support for a Java Processor
Type-Safe and Portable Support for Packed Data (Experience Paper)
Rely-Guarantee Protocols
An Efficient Vectorized Hash Table for Batch Computations
The Cartesian approach to context
Architectural Reflection for Software Evolution
Object-Oriented Programming without Inheritance (Invited Talk)
Proceedings of the 12th Workshop on Formal Techniques for Java-Like Programs, FTFJP 2010, Maribor, Slovenia, June 22, 2010
Protocol Classes for Designing Reliable Distributed Environments
Vincent: Green Hot Methods in the JVM (Extended Abstract)
Fair Termination of Multiparty Sessions
IceDust: Incremental and Eventual Computation of Derived Values in Persistent Object Graphs
Implicit Staging of EDSL Expressions: A Bridge between Shallow and Deep Embedding
What's the Optimal Performance of Precise Dynamic Race Detection? - A Redundancy Perspective
Higher-Order Demand-Driven Program Analysis
Classes as Layers: Rewriting Design Patterns with COP: Alternative Implementations of Decorator, Observer, and Visitor
Beneath the bytecode: observing the JVM at work using bytecode instrumentation
True Modules for Java-like Languages
Towards Type-Safe JCop: A type system for layer inheritance and first-class layers
Object Invariants in Dynamic Contexts
A Reflective Approach to Dynamic Software Evolution
The Implementation of a Distributed Smalltalk
MHDeS: deduplicating method handle graphs for efficient dynamic JVM language implementations
The evolution of Scala: PLE'14 keynote
Infrastructure-Free Logging and Replay of Concurrent Execution on Multiple Cores
A context management infrastructure with language integration support
UpgradeJ: Incremental Typechecking for Class Upgrades
Integrating Independently-Developed Components in Object-Oriented Languages
MADAPT: Managed Aspects for Dynamic Adaptation based on Profiling Techniques
dart2java: Running Dart in Java-based Environments
Design Templates for Collective Behavior
Accelerating Dynamically-Typed Languages on Heterogeneous Platforms Using Guards Optimization
Towards tool support for pattern-based secure and dependable systems development
Minimize aspect interaction re-evaluation due to software evolution
A New Definition of the Subtype Relation
How Do Java Programs Use Inheritance? An Empirical Study of Inheritance in Java Software
Behavioral Simulation Based on Knowledge Objects
The Expression Problem, Gracefully
Runtime Instrumentation for Reactive Components
Deep Static Modeling of invokedynamic
Understanding Concurrency Bugs in Real-World Programs with Kotlin Coroutines
Compiling generics through user-directed type specialization
Hinted Dictionaries: Efficient Functional Ordered Sets and Maps
Binary Component Adaptation
Subtyping Is Not a Good "Match" for Object-Oriented Languages
Joinpoint Inference from Behavioral Specification to Implementation
Sharing Properties in a Uniform Object Space
Composing Software in an Age of Dissonance (Invited Talk)
Towards context-aware propagators: language constructs for context-aware adaptation dependencies
Name Collision in Multiple Classification Hierarchies
Supporting Explicit Disambiguation of Multi-Methods
Static Analysis for Asynchronous JavaScript Programs
Practical information flow for legacy web applications
Empirical Study of Object-Layout Strategies and Optimization Techniques
Coinductive Type Systems for Object-Oriented Languages
Inheritance of Synchronization Constraints in Concurrent Object-Oriented Programming Languages
Generating Concurrency Checks Automatically
Creating and using domain-specific language features
Contracts in the Wild: A Study of Java Programs
Design-Based Pointcuts Robustness Against Software Evolution
Improving the development of context-dependent Java applications with ContextJ
A Co-relational Model of Data for Large Shared Data Banks
Safe Cross-Language Inheritance
Mailbox Abstractions for Static Analysis of Actor Programs
On Validity of Program Transformations in the Java Memory Model
Safe Transferable Regions
Predicate Classes
Adding State and Visibility Control to Traits Using Lexical Nesting
Spontaneous Container Services
A flow-insensitive, modular effect system for purity
A semantics for context-oriented programming with layers
Holistic Semi-Automated Software Refactoring
Contract Systems Need Domain-Specific Notations (Pearl/Brave New Idea)
Data interface + algorithms = efficient programs: separating logic from representation to improve performance
Automatic Root Cause Quantification for Missing Edges in JavaScript Call Graphs
Using Objects for Next Generation Communication Services
Java Bytecode Normalization for Code Similarity Analysis
DSL evolution through composition
Type-directed, whitespace-delimited parsing for embedded DSLs
A Middleware Framework for the Persistence and Querying of Java Objects
Short Paper: The Meaning of Attack-Resistant Systems
Erlang - Software for a Concurrent World
The OSI Managed-Object Model
A Semantic Analysis of C++ Templates
Behavioural Types for Local-First Software
Enhancing JavaScript with Transactions
Capsules and Types in Fresco: Program Verification in Smalltalk
Towards a Java Subtyping Operad
Monadic Type-And-Effect Soundness
Automation of Refactoring and Refactoring Suggestions for TTCN-3 Test Suites. The TRex TTCN-3 Refactoring and Metrics Tool
A Program Logic for First-Order Encapsulated WebAssembly
Resolving synchronization conflicts in role-based multimodel-synchronization environments
Using reified contextual information for safe run-time adaptation of software product lines
Proceedings of 16th Workshop on Formal Techniques for Java-like Programs, FTfJP@ECOOP 2014, Uppsala, Sweden, July 28 - August 1, 2014
Reducing and eliding read barriers for concurrent garbage collectors
Babelsberg/JS - A Browser-Based Implementation of an Object Constraint Language
We are all economists now: economic utility for multiple heap sizing
Accelerating parser combinators with macros
Type Abstraction for Relaxed Noninterference
Translating classes to first-order logic: an example
Consistency Checking of Statechart Diagrams of a Class Hierarchy
Ferrite: A Judgmental Embedding of Session Types in Rust
An Effectful Object Calculus
The Treatment of Persistent Objects in Arjuna
A Bytecode Translator for Distributed Execution of "Legacy" Java Software
Managing the Evolution of Aspect-Oriented Software with Model-Based Pointcuts
A Framework for Resource Dependent EDSLs in a Dependently Typed Language (Pearl)
The Single-Writer Principle in CRDT Composition
Automated Testing of Eclipse and NetBeans Refactoring Tools
Advanced Refactoring in the Eclipse JDT: Past, Present, and Future
Computing Stack Maps with Interfaces
A Reflective Model of Inheritance
Permission and Authority Revisited towards a formalisation
A Mechanical Soundness Proof for Subtyping Over Recursive Types
Maintaining Canonical Form After Edge Deletion
A Type System for Reachability and Acyclicity
Building debuggers and other tools: we can "have it all"
Panel: Aims, Means, and Future of Object-Oriented Languages
Programming with Crosscutting Effective Views
Modern Concurrency Abstractions for C #
A Metaobject Protocol for Optimizing Application-Specific Run-Time Variability
Large-scale smart grids as system of systems
Reflection for Statically Typed Languages
Demeter Interfaces: Adaptive Programming Without Surprises
Automatic inference of model fields and their representation
Transaction Layers: Controlling Granularity of Change in Live Programming Environments
NWGraph: A Library of Generic Graph Algorithms and Data Structures in C++20
Composition and Reuse with Compiled Domain-Specific Languages
On the Monitorability of Session Types, in Theory and Practice
A Declarative Language for Context Activation
Message Dispatch on Pipelined Processors
Related Types
Assuring Object-Oriented Architecture
Hoogle⋆: Constants and λ-abstractions in Petri-net-based Synthesis using Symbolic Execution
A Relational Model of Object Collaborations and Its Use in Reasoning About Relationships
Falling Back on Executable Specifications
A Proposal for Uniform Abstract Modeling of Feature Interactions in UML
Scaling Up: Revisiting Mining Android Sandboxes at Scale for Malware Classification (Replication Paper)
A Study of The Fragile Base Class Problem
Promising Compilation to ARMv8 POP
Object-Oriented Programming, Proceedings of the 8th European Conference, ECOOP '94, Bologna, Italy, July 4-8, 1994
Regional Logic for Local Reasoning about Global Invariants
Multi-method Dispatch Using Multiple Row Displacement
Roles and Dynamic Subclasses: A Modal Logic Approach
Garbage collection in object oriented systems (workshop session)
Tinygrace: A Simple, Safe, and Structurally Typed Language
On Using VeriFast, VerCors, Plural, and KeY to Check Object Usage (Experience Paper)
Legato: An At-Most-Once Analysis with Applications to Dynamic Configuration Updates
Tierless Programming and Reasoning for Networks
Counting Messages as a Proxy for Average Execution Time in Pharo
Responders: Language Support for Interactive Applications
Dealing with Variability in API Misuse Specification
Rust for Morello: Always-On Memory Safety, Even in Unsafe Code (Experience Paper)
The Billion-Dollar Fix - Safe Modular Circular Initialisation with Placeholders and Placeholder Types
ICOOOLPS '19: Proceedings of the 14th Workshop on Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems, London, UK, 19 July 2019
Enabling Modularity and Re-use in Dynamic Program Analysis Tools for the Java Virtual Machine
Harmonizing textual and graphical visualizations of domain specific models
Featherweight EventCJ: a core calculus for a context-oriented language with event-based per-instance layer transition
Proceedings of the 10th International Workshop on Context-Oriented Programming: Advanced Modularity for Run-time Composition, COP@ECOOP 2018, Amsterdam, Netherlands, July 16, 2018
Flexible Alias Protection
Augmenting Automatically Generated Unit-Test Suites with Regression Oracle Checking
The LAN-simulation: A Refactoring Lab Session
A Refinement Algebra for Object-Oriented Programming
Eventually Sound Points-To Analysis with Specifications
Near Optimal Hierarchical Encoding of Types
Scoping changes in self-supporting development environments using context-oriented programming
Automated Test Case Generation from Dynamic Models
ECOOP 2013 - Object-Oriented Programming - 27th European Conference, Montpellier, France, July 1-5, 2013. Proceedings
Sulong - execution of LLVM-based languages on the JVM: position paper
Building trustworthy software with CakeML
InferType: A Compiler Toolkit for Implementing Efficient Constraint-Based Type Inference
WebGlitch: A Randomised Testing Tool for the WebGPU API (Experience Paper)
Lightweight Diagramming for Lightweight Formal Methods: A Grounded Language Design
Towards Aggregate Programming in Scala
ECOOP '89: Proceedings of the Third European Conference on Object-Oriented Programming, Nottingham, UK, July 10-14, 1989
Fractional permissions without the fractions
Understanding TypeScript
Procedure-modular verification of control flow safety properties
Composing graphical languages
Generic Approach to Certified Static Checking of Module-like Constructs
A Trace Model for Pointers and Objects
Making Type Inference Practical
Refinements for Multiparty Message-Passing Protocols: Specification-Agnostic Theory and Implementation
Reference Capabilities for Concurrency Control
Negligent Class Loaders for Software Evolution
The Essence of Nested Composition
Exception Handling: A Field Study in Java and .NET
Brand Objects for Nominal Typing
Gradual Typestate
Satisfaction, Time Investment and Success in Students' Programming Exercise
Mutation-Based Lifted Repair of Software Product Lines
Transactions and objects (workshop session)
Implementation of a Feature-Based Context-Oriented Programming Language
A Machine Model for Aspect-Oriented Programming
What are the Odds?: probabilistic programming in Scala
Distributed Asynchronous Collections: Abstractions for Publish/Subscribe Interaction
Implementing scoped method tracing with ContextJS
HOBBIT: Hashed OBject Based InTegrity
A Type-Directed Operational Semantics For a Calculus with a Merge Operator
1st Workshop on Refactoring Tools, WRT 2007, in conjunction with 21st European Conference on Object-Oriented Programming, July 30 - August 03, 2007, Berlin, Germany, Proceedings
Eclat: Automatic Generation and Classification of Test Inputs
RAM-SE'06-ECOOP'06 Workshop on Reflection, AOP, and Meta-Data for Software Evolution, Proceedings, Nantes, France, July 4, 2006
Synthesis-Aided Crash Consistency for Storage Systems
Matching Objects with Patterns
Towards a Decoupled Context-Oriented Programming Language for the Internet of Things
An Object-Oriented Exception Handling System for an Object-Oriented Language
Using Java 6 Compiler as a Refactoring and an Analysis Engine
Building Code Transpilers for Domain-Specific Languages Using Program Synthesis (Experience Paper)
Transparent Object Proxies in JavaScript
An Object Modelling Technique for Conceptual Design
Prototyping an Interactive Electronic Book System Using an Object-Oriented Approach
On Subtyping and Matching
Secret Valley
Transient Typechecks Are (Almost) Free
Architectural Reasoning in ArchJava
Debugging Concurrent Systems Based on Object Groups
On Some Algorithms for Multiple Inheritance in Object-Oriented Programming
39th European Conference on Object-Oriented Programming, ECOOP 2025, Bergen, Norway, June 30 - July 2, 2025
AJaTS: AspectJ Transformation System
Programming highly mobile cloud applications of the future
CDDiff: Semantic Differencing for Class Diagrams
Asynchronous Data Retrieval from an Object-Oriented Database
2 nd Workshop on Graphical Modeling Language Development
Practical API Protocol Checking with Access Permissions
Safely Composable Type-Specific Languages
Morphing: Safely Shaping a Class in the Image of Others
Spegion: Implicit and Non-Lexical Regions with Sized Allocations
Peace COrP: learning to solve conflicts between contexts
Value Partitioning: A Lightweight Approach to Relational Static Analysis for JavaScript
Inheritance in Actor Based Concurrent Object-Oriented Languages
Optimization Coaching for JavaScript
Data Consistency in Transactional Storage Systems: A Centralised Semantics
Concurrency Features for the Trellis/Owl Language
A Lightweight Method for Generating Multi-Tier JIT Compilation Virtual Machine in a Meta-Tracing Compiler Framework
A Sound Type System for Secure Currency Flow
A calculus for constraint-based flow typing
Declarative definition of contexts with polymorphic events
Verifying Lock-Free Search Structure Templates
ECOOP 2002 - Object-Oriented Programming, 16th European Conference, Malaga, Spain, June 10-14, 2002, Proceedings
Fickle : Dynamic Object Re-classification
Sequential Object Monitors
Loci: Simple Thread-Locality for Java
Putting Objects to Work: Hypermedia as the Subject Matter and the Medium for Computer-Supported Cooperative Work
ECOOP'96 - Object-Oriented Programming, 10th European Conference, Linz, Austria, July 8-12, 1996, Proceedings
Dataflow constructs for a language extension based on the algebra of communicating processes
Predicting Feature Interactions in Component-Based Systems
Automated Large-Scale Multi-Language Dynamic Program Analysis in the Wild (Tool Insights Paper)
Efficient Reflection String Analysis via Graph Coloring
Structured analysis and object oriented analysis (panel session)
TaDA: A Logic for Time and Data Abstraction
OpenJIT: An Open-Ended, Reflective JIT Compiler Framework for Java
Multi-view data types for scalable concurrency in the multi-core era
A Reflective Architecture for an Object-Oriented Distributed Operating System
Evolving SaaS based on reflective Petri nets
Finally, a Polymorphic Linear Algebra Language (Pearl)
Can We Avoid High Coupling?
Verified Compilation and Optimization of Floating-Point Programs in CakeML
Application optimization when using gradual typing
Short Paper: On High-Assurance Information-Flow-Secure Programming Languages
An Aspect-Aware Outline Viewer
Proceedings for the 1st workshop on Script to Program Evolution, STOP '09, Genova, Italy, July 6, 2009
Multi-Graded Featherweight Java
Modal Object Diagrams
37th European Conference on Object-Oriented Programming, ECOOP 2023, Seattle, Washington, United States, July 17-21, 2023
Beyond Objects
Model-based tool support for consistent three-way merging of EMF models
Object Oriented Interoperability
Flow-Sensitive Type-Based Heap Cloning
Verifying backwards compatibility of object-oriented libraries using Boogie
ITCORE: A Type Inference Package for Refactoring Tools
Rewritable Reference Attributed Grammars
Doubts about the Positive Impact of Static Type Systems on Programming Tasks in Single Developer Projects - An Empirical Study
Formal Language Recognition with the Java Type Checker
Cooking the Books: Formalizing JMM Implementation Recipes
Profile-Guided Field Externalization in an Ahead-Of-Time Compiler
Modelling a Distributed Cached Store for Garbage Collection: The Algorithm and Its Correctness Proof
Consistency Types for Safe and Efficient Distributed Programming
Inference of Reference Immutability
Copying and Comparing: Problems and Solutions
Metaphoric Polymorphism: Taking Code Reuse One Step Further
Fokus!MBT: a multi-paradigmatic test modeling environment
Ambient-Oriented Programming in AmbientTalk
Verification games: making verification fun
State-Sensitive Points-to Analysis for the Dynamic Behavior of JavaScript Objects
Prisma: A Tierless Language for Enforcing Contract-Client Protocols in Decentralized Applications (Extended Abstract)
K-LLVM: A Relatively Complete Semantics of LLVM IR
Featherweight Jigsaw: A Minimal Core Calculus for Modular Composition of Classes
A Big Step from Finite to Infinite Computations (SCICO Journal-first)
Partial Redundancy Elimination in Two Iterative Data Flow Analyses
Wastrumentation: Portable WebAssembly Dynamic Analysis with Support for Intercession
Discovering Algebraic Specifications from Java Classes
Efficient profiling of actor-based applications in parallel and distributed systems
JavaCtx: seamless toolchain integration for context-oriented programming
Correctness of Partial Escape Analysis for Multithreading Optimization