yusuke1997/dblp-id-title huggingface dataset:
What Programmers Do with Inheritance in Java
An Overview of OOPS+, An Object-Oriented Database Programming Language
Extensibility for the Masses - Practical Extensibility with Object Algebras
Really Automatic Scalable Object-Oriented Reengineering
Proceedings of the Third Workshop on Process-Based Approaches for Model-Driven Engineering, PMDE@ECOOP 2013, Montpellier, France, July 1, 2013
The Use of Overloading in Java Programs
Modeling Crosscutting in Aspect-Oriented Mechanisms
Semi-automatic controller design of Java-like models
Java on 1000 Cores: Tales of Hardware/Software Co-design
Expressive Pointcuts for Increased Modularity
Conceptual Design of Active Object-Oriented Database Applications Using Multi-level Diagrams
Detecting Invalid Layer Combinations Using Control-Flow Analysis for Android
An Object-Oriented Framework for the Formal Verification of Processors
Bridging islands of specialized code using macros and reified types
Four Steps and a Rest in Putting an Object-Oriented Programming Environment to Practical Use
Compiling Tree Transforms to Operate on Packed Representations
Towards Runtime Adaptation in a SOA Environment
Optimizing Sideways Composition: Fast Context-oriented Programming in ContextPyPy
ContextLua: dynamic behavioral variations in computer games
Implementing Concurrency Control in Reliable Object-Oriented Systems
Defensive Points-To Analysis: Effective Soundness via Laziness
Code Sharing among Virtual Machines
A Calculus of Untyped Aspect-Oriented Programs
ECOOP 2000 - Object-Oriented Programming, 14th European Conference, Sophia Antipolis and Cannes, France, June 12-16, 2000, Proceedings
Ptolemy: A Language with Quantified, Typed Events
Customization of Java Library Classes Using Type Constraints and Profile Information
Improving AOP Systems' Evolvability by Decoupling Advices from Base Code
On the Design of Distributed Programming Models
Theory and Practice of Coroutines with Snapshots
MTC Flow: a tool to design, develop and deploy model transformation chains
Lightweight Support for Magic Wands in an Automatic Verifier
Multiple Aggregate Entry Points for Ownership Types
Predicate-C: an efficient and generic runtime system for predicate dispatch
Semantics of Smalltalk-80
Providing Persistent Objects in Distributed Systems
Towards verified construction of correct and optimised GPU software
LeakBot: An Automated and Lightweight Tool for Diagnosing Memory Leaks in Large Java Applications
Type Inference of SELF
ECOOP'93 - Object-Oriented Programming, 7th European Conference, Kaiserslautern, Germany, July 26-30, 1993, Proceedings
Feature-Oriented Programming with Object Algebras
First Steps Towards Fully Abstract Semantics for Object-Oriented Languages
ECOOP'99 - Object-Oriented Programming, 13th European Conference, Lisbon, Portugal, June 14-18, 1999, Proceedings
The need for capability policies
FTfJP 2021: Proceedings of the 23rd ACM International Workshop on Formal Techniques for Java-like Programs, Virtual Event, Denmark, 13 July 2021
Trust, but Verify: Two-Phase Typing for Dynamic Languages
Techniques and applications for guest-language safepoints
Specifying I/O using abstract nested hoare triples in separation logic
Runtime Support for Type-Safe Dynamic Java Classes
Mining Evolution of Object Usage
Encoding Featherweight Java with assignment and immutability using the Coq proof assistant
GraalSqueak: A Fast Smalltalk Bytecode Interpreter Written in an AST Interpreter Framework
A type system for regular expressions
An Extended Buffered Memory Model With Full Reorderings
Deltatalk: An Empirically and Aesthetically Motivated Simplification of the Smalltalk-80 Language
Source code patches from dynamic analysis
Selecting an Efficient OO Integration Testing Strategy: An Experimental Comparison of Actual Strategies
A Context-Oriented Programming Approach to Dependency Hell
Family Polymorphism
Row and Bounded Polymorphism via Disjoint Polymorphism
Compositional Static Value Analysis for Higher-Order Numerical Programs
Improving Method Extraction: A Novel Approach to Data Flow Analysis Using Boolean Flags and Expressions
Implementation Techniques for Integral Version Management
Magic with Dynamo -- Flexible Cross-Component Linking for Java with Invokedynamic
Designing Asynchronous Multiparty Protocols with Crash-Stop Failures
A Calculus for Variational Programming
Feature Based Composition of an Embedded Operating System Family
A visual interface for type-related refactorings
Proceedings of the 13th Workshop on Formal Techniques for Java-Like Programs, FTfJP 2011, Lancaster, United Kingdom, July 25-29, 2011
ECOOP '92, European Conference on Object-Oriented Programming, Utrecht, The Netherlands, June 29 - July 3, 1992, Proceedings
Modeling Context-Dependent Aspect Interference Using Default Logics
Finding the object (workshop session)
Load-Time Structural Reflection in Java
On the Usefulness of Liveness for Garbage Collection and Leak Detection
Growing an abstract grammar: teaching language engineering
Morphing Software for Easier Evolution
Experiences on The Road to Object Utopia (Abstract)
Unifying the Design and Implementation of User Interfaces through the Object Paradigm
Proceedings of the 2nd International Workshop on Context-Oriented Programming, COP 2010, Maribor, Slovenia, June 22, 2010
Overview of a Parallel Object-Oriented Language CLIX
Representation of Complex Objects: Multiple Facets with Part-Whole Hierarchies
IntelliJML: a JML plugin for IntelliJ IDEA
Verifying Multi-object Invariants with Relationships
API Generation for Multiparty Session Types, Revisited and Revised Using Scala 3
The state of the art and future perspectives in systems of systems software architectures
Session Types for Object-Oriented Languages
Scaling CFL-Reachability-Based Points-To Analysis Using Context-Sensitive Must-Not-Alias Analysis
Integrating Constraints with an Object-Oriented Language
Generalizing Shape Analysis with Gradual Types
Mono Types - First-Class Containers for Datalog
Formal Analysis of Object-Oriented Mograms
Verifying Functional Behaviour of Concurrent Programs
A separation logic to verify termination of busy-waiting for abrupt program exit
Object-Oriented Reading Techniques for Inspection of UML Models - An Industrial Experiment
A Language-Based Approach to Secure Quorum Replication
Reusing Caches and Invariants for Efficient and Sound Incremental Static Analysis
Object Roles and Runtime Adaptation in Java
Software Verification "Across the Stack" (Invited Talk)
A Proposal for Making Eiffel Type-Safe
Fine-grained Language Composition: A Case Study
Monitoring Reactive Systems with Dynamic Channels
JavaGI : Generalized Interfaces for Java
Designing with Static Capabilities and Effects: Use, Mention, and Invariants (Pearl)
Generic Wrappers
Towards a semantic model for Java wildcards
An experimental study of the influence of dynamic compiler optimizations on Scala performance
MX: Mobile Object Exchange for Collaborative Applications
Reversible Object-Oriented Interpreters
Implementing Babylonian/S by Putting Examples Into Contexts: Tracing Instrumentation for Example-based Live Programming as a Use Case for Context-oriented Programming
Towards Modular Reasoning for Context-Oriented Programs
Aggregation in a Behaviour Oriented Object Model
Visualizing Reference Patterns for Solving Memory Leaks in Java
Defining Corecursive Functions in Coq Using Approximations
Proceedings of the 21st Workshop on Formal Techniques for Java-like Programs, FTfJP@ECOOP 2019, London, United Kingdom, July 15, 2019
Revisiting Information Hiding: Reflections on Classical and Nonclassical Modularity
Proceedings of the 7th Workshop on Reflection, AOP and Meta-Data for Software Evolution, RAM-SE 2010, Maribor, Slovenia, June 22, 2010
Inheritance as an Incremental Modification Mechanism or What Like Is and Isn't Like
Towards Strong Normalization for Dependent Object Types (DOT)
Runtime Adaptations within the QuaD2-Framework
Layer Activation Mechanism for Asynchronous Executions in JavaScript
The GOOL system: a lightweight object-oriented programming language translator
Metamodel Adaptation and Model Co-adaptation
AS-GC: An Efficient Generational Garbage Collector for Java Application Servers
Proceedings of the 10th Workshop on Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems, ICOOOLPS@ECOOP 2015, Prague, Czech Republic, July 6, 2015
Low-Level Bi-Abduction
Type-Safe Delegation for Run-Time Component Adaptation
Intimate Computing and the Memory Prothesis: A Challenge for Computer Systems Research? (Abstract)
Traceability visualization in metamodel change impact detection
JavaScript Sealed Classes
Faster than C#: efficient implementation of dynamic languages on .NET
TOOA: A Temporal Object-Oriented Algebra
Type Regression Testing to Detect Breaking Changes in Node.js Libraries
Refactoring Functional Programs at the University of Kent
Intensional Effect Polymorphism
Archface4COP: architectural interface for context-oriented programming
Perfect Is the Enemy of Good: Best-Effort Program Synthesis
Bristlecone: A Language for Robust Software Systems
Away from the sequential paradigm tarpit: modelling and programming with actors, concurrent objects and agents
Join Decompositions for Efficient Synchronization of CRDTs after a Network Partition: Work in progress report
Compiling structural types on the JVM: a comparison of reflective and generative techniques from Scala's perspective
Flow Analysis of Code Customizations
Prusti: deductive verification for Rust (keynote)
Java UI : Effects for Controlling UI Object Access
Proceedings of the 1st Workshop on Programming Language Evolution, PLE@ECOOP 2014, Uppsala, Sweden, July 28, 2014
Scala macros: let our powers combine!: on how rich syntax and static types work with metaprogramming
Modelling Java requires state
Proceedings of the 9th ECOOP Workshop on Reflection, AOP, and Meta-Data for Software Evolution, RAM-SE 2012, Beijing, China, June 13, 2012
Type-Safe Compilation of Covariant Specialization: A Practical Case
Motion Session Types for Robotic Interactions (Brave New Idea Paper)
CROCHET: Checkpoint and Rollback via Lightweight Heap Traversal on Stock JVMs
Pattern matching for object-like structures in the Go programming language
Jam - A Smooth Extension of Java with Mixins
Simple Ownership Types for Object Containment
Nesting in an Object-Oriented Language is NOT for the Birds
Static Race Detection and Mutex Safety and Liveness for Go Programs
Transparently Reconciling Transactions with Locking for Java Synchronization
In-Memory Object Graph Stores
Elementary Type Inference
A Design Method for Object-Oriented Programming
An efficient lock-aware transactional memory implementation
Towards a dynamic-update-enabled JVM
Interprocedural Exception Analysis for C++
Interprocedural Type Specialization of JavaScript Programs Without Type Analysis
Large Scale Object-Oriented Software-Development in a Banking Environment: An Experience Report
FORK: A System for Object- and Rule-Oriented Programming
ThingsMigrate: Platform-Independent Migration of Stateful JavaScript IoT Applications
Object-Oriented Programming on the Network
Exceptions in Guide, an Object-Oriented Language for Distributed Applications
Tenspiler: A Verified-Lifting-Based Compiler for Tensor Operations
Verifying Generics and Delegates
Behavioural separation with parallel usages
A Geographic Environmental Modeling System: Towards an Object-Oriented Framework
PEDroid: Automatically Extracting Patches from Android App Updates
A formal account of SSA in Java-like languages
Proceedings of the 5th International Workshop on Context-Oriented Programming, COP 2013, Montpellier, France, July 2, 2013
Proceedings of the Second International Workshop on Combined Object-Oriented Modelling and Programming Languages, COOMPL 2013, Montpellier, France, July 1, 2013
Safe, Flexible Aliasing with Deferred Borrows
Application-Only Call Graph Construction
Proceedings of the Workshop on Context-oriented Programming, COP@ECOOP 2019, July 15-19, 2019, London, UK
Proceedings of the 11th Workshop on Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems, ICOOOLPS@ECOOP 2016, Rome, Italy, July 17-22, 2016
Reasoning About Foreign Function Interfaces Without Modelling the Foreign Language
A Customizable Window-Interface to Object-Oriented Databases
Sustainable System Infrastructure and Big Bang Evolution: Can Aspects Keep Pace?
Fault-tolerant Distributed Reactive Programming
A Model for Java with Wildcards
A Uniform Transactional Execution Environment for Java
Verifying Executable Object-Oriented Specifications with Separation Logic
TreatJS: Higher-Order Contracts for JavaScripts
Using Types and Inheritance in Object-Oriented Languages
Wiring Circuits Is Easy as {0, 1, ω}, or Is It..
Programming language evolution workshop report
From Public to Private to Absent: Refactoring Java Programs under Constrained Accessibility
Do Object-Oriented Languages Need Special Hardware Support?
An Architectural Style to Integrate Components and Aspects
Best-Effort Lazy Evaluation for Python Software Built on APIs
SuperGlue: Component Programming with Object-Oriented Signals
Connecting Object Constraints with Context-oriented Programming: Scoping Constraints with Layers and Activating Layers with Constraints
Variability Abstractions: Trading Precision for Speed in Family-Based Analyses
Proceedings of the First Workshop on the Globalization of Domain Specific Languages, GlobalDSL@ECOOP 2013, Montpellier, France, July 1, 2013
Towards correct evolution of components using VPA-based aspects
Systematic Testing of Refactoring Engines on Real Software Projects
Incremental Computing by Differential Execution
Averroes: Whole-Program Analysis without the Whole Program
Aspects and Evolution: The Case for Versioned Types and Meta-Aspect Protocols
Conditional effects in fine-grained region logic
The Performance Effects of Virtual-Machine Instruction Pointer Updates
Peak Objects
A Compositional Paradigm of Automating Refactorings
Transferring Obligations Through Synchronizations
An Executable Formal Semantics of PHP
Shared Memory Implementations of Protocol Programming Languages, Data-Race-Free
Access-rights Analysis in the Presence of Subjects
Atomic Object Composition
Objects as Communicating Prolog Units
KafKa: Gradual Typing for Objects
Indirection-Bounded Call Graph Analysis
RedCard: Redundant Check Elimination for Dynamic Race Detectors
Evil Pickles: DoS Attacks Based on Object-Graph Engineering
Modular Abstract Definitional Interpreters for WebAssembly
One Way to Select Many
Time and Asynchrony in Interactions among Distributed Real-Time Objects
Is This a Bug or an Obsolete Test?
Accelerating Object-Sensitive Pointer Analysis by Exploiting Object Containment and Reachability
Assessing primitives performance on multi-stage execution
OOP in the real world (panel session)
A Two-Component Language for COP
Kilim: Isolation-Typed Actors for Java
A theory of typestate-oriented programming
Evaluating the Design of the R Language - Objects and Functions for Data Analysis
Dynamic Grouping in an Object-Oriented Virtual Memory Hierarchy
Architecture Models for Interactive Software
Modular Internet Programming with Cells
34th European Conference on Object-Oriented Programming, ECOOP 2020, Berlin, Germany (Virtual Conference), November 15-17, 2020
Model driven development of context aware software systems
Java Wildcards Meet Definition-Site Variance
GraCoT , a tool for co-creation of models and metamodels in specific domains
Defining Name Accessibility Using Scope Graphs
EPEE: an Eiffel Environment to Program Distributed Memory Parallel Computers
Automated Detection of Refactorings in Evolving Components
On the Darker Side of C++
Transactional contexts: harnessing the power of context-oriented reflection
Simple and Effective Type Check Removal through Lazy Basic Block Versioning
Operational Semantics for Secure Interoperation
The Elements of Decision Alignment
LogicObjects: a linguistic symbiosis approach to bring the declarative power of Prolog to Java
30th European Conference on Object-Oriented Programming, ECOOP 2016, Rome, Italy, July 18-22, 2016
Space-Efficient Gradual Typing in Coercion-Passing Style
Method Safety Mechanism for Asynchronous Layer Deactivation
Exact Separation Logic: Towards Bridging the Gap Between Verification and Bug-Finding
Activity Contexts: Improving Modularity in Blockchain-based Smart Contracts using Context-oriented Programming
Framework for Static Analysis of PHP Applications
MiCA: A Compositional Architecture for Gossip Protocols
Towards model and language composition
Efficient Layered Method Execution in ContextAmber
Partial Solutions to VerifyThis 2016 Challenges 2 and 3 with VeriFast
Balloon Types: Controlling Sharing of State in Data Types
An Object-Oriented Logic Language for Modular System Specification
Validity Invariants and Effects
AOP: Does It Make Sense? The Case of Concurrency and Failures
Improving aspect-oriented programming with dynamic code evolution in an enhanced Java virtual machine
Conformance, Genericity, Inheritance and Enhancement
Lana: An Approach to Programming Autonomous Systems
Parametric Aspects: A Proposal
Is It Dangerous to Use Version Control Histories to Study Source Code Evolution?
Taming Message Passing: Efficient Method Look-Up for Dynamically Typed Languages
Modelling Feature Interactions in Mobile Phones
How to prove type soundness of Java-like languages without forgoing big-step semantics
Proceedings of the Second Workshop on Graphical Modeling Language Development, GMLD '13, Montpellier, France, July 2, 2013
Empirical assessment of C++-like implementations for multiple inheritance
Bottom-Up Synthesis of Memory Mutations with Separation Logic
32nd European Conference on Object-Oriented Programming, ECOOP 2018, Amsterdam, The Netherlands, July 16-21, 2018
Multiparty Asynchronous Session Types: A Mechanised Proof of Subject Reduction
Chai : Traits for Java-Like Languages
Type-Safe Prototype-Based Component Evolution
Dynamic Refactorings: Improving the Program Structure at Run-time
Aliasing control with view-based typestate
Real-time collaborative Scala development with Clide
Towards Ontology-Based Program Analysis
How to Avoid Making a Billion-Dollar Mistake: Type-Safe Data Plane Programming with SafeP4
Trufflereloader: a low-overhead language-neutral reloader
Why Don't People Use Refactoring Tools?
CPA beats ∞-CFA
Concurrent Data Structures Linked in Time
Quality and Understandability of Use Case Models
COP@ECOOP 2021: Proceedings of the 13th ACM International Workshop on Context-Oriented Programming and Advanced Modularity, Virtual Event, Denmark, July 12, 2021
Wrappers to the Rescue
Owicki-Gries Reasoning for C11 RAR
Harmless compiler plugins
Multiverse Debugging: Non-Deterministic Debugging for Non-Deterministic Programs (Brave New Idea Paper)
Simple Profile Rectifications Go a Long Way - Statistically Exploring and Alleviating the Effects of Sampling Errors for Program Optimizations
A Direct-Style Effect Notation for Sequential and Parallel Programs
NumLin: Linear Types for Linear Algebra
Constraint Semantics for Abstract Read Permissions
Extending JML for Modular Specification and Verification of Multi-threaded Programs
HERCULE : Non-invasively Tracking Java TM Component-Based Application Activity
Design and Partial Evaluation of Meta-Objects for a Concurrent Reflective Language
Building Secure Systems with LIO (Demo)
On Leveraging Tests to Infer Nullable Annotations
Morpheus: Automated Safety Verification of Data-Dependent Parser Combinator Programs
Coordination Requirements Expressed in Types for Active Objects
Context-Oriented Image Processing: Reconciling genericity and performance through contexts
Using Structure-Based Recommendations to Facilitate Discoverability in APIs
Towards a Type System for R
Ensuring Convergence and Invariants Without Coordination
Correct Refactoring of Concurrent Java Code
codeQuest: Scalable Source Code Queries with Datalog
JayHorn: a Java model checker
Issues and challenges in ecosystems for federated embedded systems
Methods as Assertions
Model-driven Software Refactoring
Providing Fine-grained Access Control for Java Programs
The Past, Present and Future of Smalltalk
Safer context (de)activation: through the prompt-loyal strategy
A mechanism for flexible dynamic trait replacement
Proceedings of the Programming Experience 2016 (PX/16) Workshop, PX/16, Rome, Italy, July 18, 2016
Frameworks in the Financial Engineering Domain - An Experience Report
An Incremental Class Reorganization Approach
Object-Oriented Computations in Logic Programming
An Analysis of the Mozilla Jetpack Extension Framework
Fitting Round Objects into Square Databases
MTM2: Scalable Memory Management for Multi-tasking Managed Runtime Environments
An Object Model for Engineering Design
DynamicSchema: a lightweight persistency framework for context-oriented data management
Trustworthy Proxies - Virtualizing Objects with Invariants
Trace Typing: An Approach for Evaluating Retrofitted Type Systems
A Simple Context-Oriented Programming Extension to an FRP Language for Small-Scale Embedded Systems
Orthogonal to the Java Imperative
Internal Iteration Externalized
Reuse Based Refactoring Tools
ECOOP 2011 - Object-Oriented Programming - 25th European Conference, Lancaster, UK, July 25-29, 2011 Proceedings
Finding Reference-Counting Errors in Python/C Programs with Affine Analysis
Accumulation Analysis
QUIC Graphs: Relational Invariant Generation for Containers
PCLOS: A Flexible Implementation of CLOS Persistence
Constraint Based Compiler Optimization for Energy Harvesting Applications
Reasoning and Refinement in Object-Oriented Specification Languages
OOpde (workshop session): object oriented program development environments
Efficiency of subtype test in object oriented languages with generics
Typed Sets as a Basis for Object-Oriented Database Schemas
A Theory of Tagged Objects
Sound Regular Corecursion in coFJ
ECOOP 2005 - Object-Oriented Programming, 19th European Conference, Glasgow, UK, July 25-29, 2005, Proceedings
CafeSat: a modern SAT solver for Scala
Explicit Tool Support for Implicit Layer Activation
Lifestate: Event-Driven Protocols and Callback Control Flow
Dynamically Generating Callback Summaries for Enhancing Static Analysis
GlobalDSL 2013: First Workshop on the Globalization of Domain Specific Languages
Monotonicity Types for Distributed Dataflow
McSAF: A Static Analysis Framework for MATLAB
Retargeting Gradual Typing (Invited Talk)
Modular Aspect Verification for Safer Aspect-Based Evolution
Interfaces for Modular Reasoning in Context-Oriented Programming
Parameterized Modules for Classes and Extensible Functions
Generalizing Permissive-Upgrade in Dynamic Information Flow Analysis
Configuring Software Product Line Features
Synthesizing Conjunctive Queries for Code Search
Scripting .NET Using Mondrian
Generational Real-Time Garbage Collection
Information Flow Control in Cyclic Process Networks
Defining Correctness Conditions for Concurrent Objects in Multicore Architectures
Supporting Unanticipated Dynamic Adaptation of Application Behaviour
Proceedings of the Fifth Annual Scala Workshop, SCALA@ECOOP 2014, Uppsala, Sweden, July 28-29, 2014
Generating Virtual Scenarios for Cyber Ranges from Feature-Based Context-Oriented Models: A Case Study
Heap Decomposition Inference with Linear Programming
Going Beyond Objects with Design Patterns (Abstract)
Proceedings of the Workshop on the Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems, ICOOOLPS 2010, Maribor, Slovenia, June 22, 2010
Higher-Order Hierarchies
Mobile Objects and Mobile Agents: The Future of Distributed Computing?
Hinted Dictionaries: Efficient Functional Ordered Sets and Maps (Extended Abstract)
Why Do Scala Developers Mix the Actor Model with other Concurrency Models?
Generalising the BETA Type System
SCOOP, Structured Concurrent Object-Oriented Prolog
Typed Object-Oriented Functional Programming with Late Binding
On the interplay between the semantics of Java's finally clauses and the JML run-time checker
Converting Parallel Code from Low-Level Abstractions to Higher-Level Abstractions
Towards an IoT ecosystem
Higher-Order Reactive Programming with Incremental Lists