yusuke1997/dblp-id-title huggingface dataset:
Constrained objects for modeling complex structures (extended abstract) (poster session)
Automatic parallelization of pure method calls via conditional future synthesis
Software development: arts & crafts or math & science?
OrcO: a concurrency-first approach to objects
Efficient data race and deadlock prevention in concurrent object-oriented programs
Proceedings of the Seventh Annual Conference on Object-Oriented Programming Systems, Languages, and Applications, OOPSLA 1992, Vancouver, British Columbia, Canada, October 18-22, 1992
MI - An Object Oriented Environment for Integration of Scientific Applications
Optimizing the evaluation of patterns in pointcuts
Assessing the benefits of computational offloading in mobile-cloud applications
Ulterior reference counting: fast garbage collection without a long wait
The Apertos Reflective Operating System: The Concept and its Implementation
Cognitive architectures: a way forward for the psychology of programming
Uniform proxies for Java
Modular verification of higher-order methods with mandatory calls specified by model programs
Worked examples for sound object-oriented pedagogy: a "killer" workshop
Improving architecture testability with patterns
Modules and Type Checking in PL/LL
JIT compilation policy for modern machines
Dynamic optimization for efficient strong atomicity
Predicate dispatch for aspect-oriented programming
To achieve our highest goals, we must be willing to abandon them
Programming with enumerable sets of structures
Integrating static analysis and testing for firewall policies
Uniqueness and reference immutability for safe parallelism
A cost model for a graph-based intermediate-representation in a dynamic compiler
Object Fault Handling for Persistent Programming Languages: A Performance Evaluation
2 nd workshop on domain-specific visual languages
Adaptable symbol table management by meta modeling and generation of symbol table infrastructures
SPLASH'13 - The Proceedings of the 2013 Companion Publication for Conference on Systems, Programming, & Applications: Software for Humanity, Indianapolis, IN, USA, October 26-31, 2013
Combining structural subtyping and external dispatch
Using refactorings to automatically update component-based applications
Communication as Fair Distribution of Knowledge
Virtualization support for dynamic core library update
ATL: a QVT-like transformation language
Visualizing the Behavior of Object-Oriented Systems
Evaluation and usability of programming languages and tools: (PLATEAU)
Sensors, actuators and services: a distributed approach
Instant pickles: generating object-oriented pickler combinators for fast and extensible serialization
Panel on visual programming
Decentralizing execution of composite web services
Agile practices in embedded systems
Improve software quality with SemmleCode: an eclipse plugin for semantic code search
2nd workshop on assessment of contemporary modularization techniques (ACoM 2008)
Efficient software model checking of soundness of type systems
Automated testing of non-functional requirements
The Design and Performance of a Hard Real-Time Object Event Service
Testing domain-specific languages in eclipse
Living in the comfort zone
Selecting object-oriented source code metrics to improve predictive models using a parallel genetic algorithm
Improving the Android development lifecycle with the VALERA record-and-replay approach
Gradual typing for generics
Almost free concurrency! (using GOF patterns)
X10: an object-oriented approach to non-uniform cluster computing
Probability type inference for flexible approximate programming
Are Java programmers transitioning to multicore?: a large scale study of java FLOSS
An abstract interpretation framework for refactoring with application to extract methods with contracts
Penumbra: an Eclipse plugin for introductory programming
Helping Children Eat Well via Mobile Software Technologies
A Framework for Scalbale Dissemination-Based Systems
Efficiently combining parallel software using fine-grained, language-level, hierarchical resource management policies
A decade of modeling financial vehicles
Learning a strategy for adapting a program analysis via bayesian optimisation
Static Type Inference for Parametric Classes
How difficult is the transition from OOA to OOD? (panel session)
Executing code in the past: efficient in-memory object graph versioning
Smaller footprint for Java collections
The Point of View Notion for Multiple Inheritance
Scrambler: dynamic layout adaptation
SugarJ: library-based language extensibility
Reconciling Objects and Multilevel Security (Panel)
Portable inter-workgroup barrier synchronisation for GPUs
A translation approach to component specification
A theory of aspects as latent topics
In Search of Types
We should stop claiming generality in our domain-specific language papers (extended abstract)
MySQL to NoSQL: data modeling challenges in supporting scalability
Use of dynamic, reflective, and meta-level language facilities in the application domain
Mobile devices as interfaces for steering cloud-based high-performance computations
OpenRefactory/C: an infrastructure for developing program transformations for C programs
IFRit: interference-free regions for dynamic data-race detection
The tradeoffs of societal computing
ModelTalk: a DSL workbench in action
Performance and scalability of EJB applications
Contributions to Teaching Object Oriented Design and Programming
The Mount Sinai Human Resources Case Management System: an example of rapid application development in a Java environment
Hurricane: An Optimizing Compiler for Smalltalk
The chemical approach to typestate-oriented programming
Modeling and implementing software architecture with acme and archJava
RHEA: a reactive, heterogeneous, extensible, and abstract framework for dataflow programming
Framework support for usability evaluation of domain-specific languages
Programming with Explicit Metaclasses in Smalltalk-80
Can We Do Without Monotonically Non-Decreasing Levels in Class Hierarchies?
Refactoring for generalization using type constraints
Moving Structures between Smalltalk Images
AGERE! (actors and agents reloaded): splash 2011 workshop on programming systems, languages and applications based on actors, agents and decentralized control
Compiling Away the Meta-Level in Object-Oriented Concurrent Reflective Languages Using Partial Evaluation
Method-level phase behavior in java workloads
Software evolution and the moving picture metaphor
Finding reusable data structures
Synthesizing reactive systems from LSC requirements using the play-engine
Reducing Transfer Delay Using Java Class File Splitting and Prefetching
Proceedings of the Workshop on Future Programming, FPW@SPLASH 2015, Pittsburgh, PA, USA, October 26, 2015
QuickUML: a beginner's UML tool
Fluid AOP join point models
Discount method for programming language evaluation
Integrating Object Oriented Technology and Security in Medical Database Systems
Proceedings of the 2019 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software, Onward! 2019, Athens, Greece, October 23-24, 2019
How conceptual system architecture leads to business process
Object-Oriented System Modeling with OMT
Unbounded superoptimization
Re-engineering the algorithma project for long-term maintenance
Things they would not teach me of in college: what Microsoft developers learn later
Genericity versus Inheritance Reconsidered: Self-Reference Using Generics
Workshop preview of the 15th workshop on domain specific modeling (DSM 2015)
Synthesis modulo recursive functions
Columnar objects: improving the performance of analytical applications
The future of SOA: what worked, what didn't, and where is it going from here?
Towards a Methodology for Explicit Composition of MetaObjects
Practical second Futamura projection: partial evaluation for high-performance language interpreters
An approach to monitor application states for self-managing (autonomic) systems
Combining visual and textual languages for dyslexia
Efficient subcubic alias analysis for C
Reframing the Liskov substitution principle through the lens of testing
An overview of Scade, a synchronous language for safety-critical software (keynote)
Managed data: modular strategies for data abstraction
Specifying CSS layout with reference attribute grammars
OOPSLA 2002 Practitioners Reports, OOPSLA 2002, Seattle, Washington, USA, November 4-8, 2002
The 3rd ACM workshop on refactoring tools (WRT'09)
Low-overhead and fully automated statistical debugging with abstraction refinement
Method-specific dynamic compilation using logistic regression
Can undergraduates script their own refactorings?
Object-oriented real-time concurrency
A User Interface Toolkit Based on Graphical Objects and Constraints
A Probe-Based Monitoring Scheme for an Object-Oriented Distributed Operating System
A Smalltalk Window System Based on Constraints
Thorn: robust, concurrent, extensible scripting on the JVM
A case study in language-based security: building an I/O library for Wyvern
Building high-performance applications and services in Java: an experiential study
Jazz: a collaborative application development environment
Flexible modeling tools for pre-requirements analysis: conceptual architecture and research challenges
Formalizing UML. Why? How?
Advanced debugging techniques to identify concurrency bugs in actor-based programs
Green: a flexible UML class diagramming tool for eclipse
Proceedings of the 11th ACM SIGPLAN International Workshop on Virtual Machines and Intermediate Languages, VMIL@SPLASH 2019, Athens, Greece, October 22, 2019
Some usability hypotheses for verification
HAWKEYE: effective discovery of dataflow impediments to parallelization
From concrete to abstract: the power of generalization
Automated upgrading of component-based applications
PolyD: a flexible dispatching framework
Security for Object-Oriented Systems: An Editorial Overview
A pattern-based approach to DSL development
Workshop on transitioning to multicore (TMC 2011): overview abstract
OOPSLA workshop #18: "Object technology, architecture, and domain analysis - experiences in making the connection"
Language support for asynchronous event handling in the invocation call stack
Proceedings of the 3rd International Workshop on Reactive and Event-Based Languages and Systems, Amsterdam, Netherlands, November 1, 2016
Javari: adding reference immutability to Java
FPW'14: future programming workshop
Composite Design Patterns
Model driven architecture development approach for pervasive computing
Addendum to the 1998 Proceedings of the Conference on Object-Oriented Programming, Systems, Languages, and Applications, OOPSLA 1998 Addendum, Vancouver, British Columbia, Canada, October 18-22, 1998
Can we crowdsource language design?
RAPID: Prototyping Control Panel Interfaces
Model checking the behavior of frameworks extended with other frameworks
Recovering execution data from incomplete observations
A simple inductive synthesis methodology and its applications
Virtual values for language extension
Randoop: feedback-directed random testing for Java
Tiling Design Patterns - A Case Study Using the Interpreter Pattern
Mining modal scenarios from execution traces
Data synchronization architectural pattern for ubiquitous learning systems
An open model infrastructure for automotive software
Tracking bad apples: reporting the origin of null and undefined value errors
How and Why to Encapsulate Class Trees
Object-oriented design quality
Some Experiments In Object-Oriented Simulation
The CloudBrowser web application framework
TS: An Optimizing Compiler for Smalltalk
BigLever software gears and the 3-tiered SPL methodology
ATL-MR: model transformation on MapReduce
in the control room of the banquet
A time-aware type system for data-race protection and guaranteed initialization
Backstage Java: making a difference in metaprogramming
Companion to the 22nd Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications, OOPSLA 2007, October 21-25, 2007, Montreal, Quebec, Canada
Interfaces and Specifications for the Smalltalk-80 Collection Classes
Composable higher-order reactors as the basis for a live reactive programming environment
Object-oriented design and implementation of the multi-agent system AgentTeam (poster session)
Xtreme programming and agile coaching
A Situated Evaluation of the Object Management Group's (OMG) Object Management Architecture (OMA)
Reasoning about Object-Oriented Programs that Use Subtypes
DevOps patterns to scale web applications using cloud services
Complexity management
Specifying and implementing refactorings
An efficient parallel heap compaction algorithm
Kava - a powerful and portable reflective Java (poster session)
Building and Maintaining Analysis-Level Class Hierarchies Using Galois Lattices
Proceedings of the 7th International Workshop on Feature-Oriented Software Development, FOSD@SPLASH 2016, Amsterdam, The Netherlands, October 30, 2016
A Logical Theory of Concurrent Objects
An introduction to fly: a smaller smalltalk
Automated test generation for access control policies
Semantic subtyping for imperative object-oriented languages
Program analysis for mobile: how and why to run WALA on your phone
The Future of Programming Languages and Programmers
Mind the gap: lessons learned from translating grammars between MontiCore and Xtext
Fabrik: A Visual Programming Environment
Building the right cloud solutions
Software speculative multithreading for Java
TD 2014: workshop on technical debt in a world of big data and big teams
Kaleidoscope: Mixing Objects, Constraints and Imperative Programming
QuA: building with reusable QoS-aware components
Subject-Oriented Programming (A Critique of Pure Objects)
A syntactic type system for recursive modules
Predictability by construction
Implementing DSLs in metaOCaml
DEMOCLES: a tool for executable modeling of platform-independent systems
Fortune teller: improving garbage collection performance in server environment using live objects prediction
SAFARI: a meta-tooling framework for generating language-specific IDE's
Ease Virtual Machine Level Tooling with Language Level Ordinary Object Pointers
MolhadoRef: a refactoring-aware software configuration management tool
DejaVu: deterministic Java replay debugger for Jalapeño Java virtual machine
Implementation and application of object oriented workflow management systems
SurveyMan: programming and automatically debugging surveys
Mobile device security
Round-trip engineering using framework-specific modeling languages
Udapt: edapt extensions for industrial application
A framework for complex time structures based on coupled lists
Automatic testing of interactive JavaScript debuggers
Compile-time type-checking for custom type qualifiers in java
SkyQuery: an aerial drone video sensing platform
Computing repair alternatives for malformed programs using constraint attribute grammars
CREST: principled foundations for decentralized systems
Example embedding
A meta-metamodel for dynamic constraint feedback in modeling languages
Whiteoak: introducing structural typing into java
The power of symmetry: unifying inheritance and generative programming
OO Testing in the Real World: Lessons for All - Panel Session
Objects and Databases (Panel)
Turning light bulbs into objects
Role Model Based Framework Design and Integration
Extending SQL-92 for OODB Access: Design and Implementation Experience
Profile Guided Offline Optimization of Hidden Class Graphs for JavaScript VMs in Embedded Systems
A domain-specific approach to architecturing error handling in pervasive computing
A generic editor
Static analysis for independent app developers
Supporting model evolution through demonstration-based model transformation
Redeveloping a high-Performance computing framework
Strictly declarative specification of sophisticated points-to analyses
Continuing professional development by practitioner integrated learning
Towards agile security in web applications
Query-point debugging
Agile programming with executable models: an open-source, standards-based eclipse environment
Usability Hypotheses in the Design of Plaid
Generating a ROS/JAUS bridge for an autonomous ground vehicle
Reflection in software engineering education
The case for teaching functional programming in discrete math
CUTE: C++ unit testing easier
Tool support for refactoring to design patterns
GUI and usage model-based test case generation for Android applications with change analysis
Reconsidering reliability in distributed actor systems
Towards a two-dimensional separation of concerns (poster session)
Technical debt: from source to mitigation
Implementing incrementalization across object abstraction
Reuse: Truth or Fiction (Panel)
Typing the Specialization Interface
Expert workflow: building knowledge-based workflow systems with object technology
Atlas: leveraging locks for non-volatile memory consistency
Using interfaces to support the testing of crosscutting features
Analyzing and Measuring Reusability in Object-Oriented Designs
@J: towards rapid development of dynamic analysis tools for the Java Virtual Machine
UML: The Language of Blueprints for Software? (Panel)
Exploring the role of sequential computation in distributed systems: motivating a programming paradigm shift
An educational perspective on database management systems and object-oriented methodology: a 12 year journey
Security oriented program transformations (or how to add security on demand)
Jiazzi: New-Age Components for Old-Fashioned Java
Agile software development for component based software engineering
Problem-Oriented Object Memory: Customizing Consistency
Design patterns: beginnings and futures
Grammar-driven generation of domain-specific language tools
An Alternative to Subclassing
Model scalability using a model recording and inference engine
Korz: Simple, Symmetric, Subjective, Context-Oriented Programming
Coarse-grain speculation for emerging processors
ModelFlow: towards reactive model management workflows
Examples that can do harm in learning programming
Immutable specifications for more concise and precise verification
Concurrency control of JavaScript with arrows
I Throw Itching Powder at Tulips
Object-Oriented Concurrent Reflective Languages can be Implemented Efficiently
Scaffolding for multiple assignment projects in CS1 and CS2
Defining communication in SOA based on discourse models
Compiler construction with a dash of concurrency and an embedded twist
Is the licensing of software engineers good for the OT community? (Panel session)
A modular QoS-enabled load management framework for component-based middleware
Tenuring Policies for Generation-Based Storage Reclamation
Efficient Dynamic Dispatch without Virtual Function Tables: The SmallEiffel Compiler
Automating engineering with a domain-specific language and a code generator
Companion to the 26th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications, OOPSLA 2011, part of SPLASH 2011, Portland, OR, USA, October 22 - 27, 2011
Tackling the efficiency problem of gradual typing
Efficient control flow quantification
Thinking with prototypes: OOPSLA 1998 workshop on prototype-based object-oriented programming
The HipHop compiler for PHP
Mutation testing for DSLs (tool demo)
Contract Soundness for Object-Oriented Languages
Name resolution strategies in variability realization languages for software product lines
Recommending refactorings when restructuring variabilities in software product lines
Which problems does a multi-language virtual machine need to solve in the multicore/manycore era?
Automatic protocol-conformance recommendations
Proceedings of the Workshop on Domain-Specific Modeling, DSM@SPLASH 2015, Pittsburgh, PA, USA, October 27, 2015
Towards seamless interfacing between dynamic languages and native code
The data, context and interaction paradigm
Gradual program analysis
Soft Issues in Software Development (Panel Session)
Accentuating the positive: atomicity inference and enforcement using correct executions
Incremental exploratory visualization of relationships in large codebases for program comprehension
Preserving the separation of concerns while composing aspects on shared joinpoints
Disjointness domains for fine-grained aliasing
Reactive chatbot programming
A feature model of actor, agent, and object programming languages
J2EE for the public administration: a success story
Enabling expressive aspect oriented modular reasoning by translucid contracts
Dynamic personal roles for ubiquitous computing
Formal underpinnings of Java
Mock roles, objects
SCuV: a novel software clustering and visualization tool
A Framework for Run-Time Systems and its Visual Programming Language
Documenting software using adaptive software artifacts
A domain specific language for enterprise grade cloud-mobile hybrid applications
Arbitrary non-contiguous pieces of computation: a new join point model for aspect-oriented programming
Theory-infected: or how i learned to stop worrying and love universal quantification
MDAbench: a tool for customized benchmark generation using MDA
Truffle: a self-optimizing runtime system
The JastAdd extensible Java compiler
Multi-Tier Functional Reactive Programming for the Web
Modularizing crosscutting concerns with ptolemy
ASPIRE: exploiting asynchronous parallelism in iterative algorithms using a relaxed consistency based DSM
Symbolic heap abstraction with demand-driven axiomatization of memory invariants
Crossfire: multiprocess, cross-browser, open-web debugging protocol
Incrementalization across object abstraction
Flexible access control for javascript
Patterns in Practice
AJEER: an aspectJ-enabled eclipse runtime
Practical predicate dispatch
Declarative programming for the cloud
Flint: fixing linearizability violations
Statistical debugging for real-world performance problems
CDSchecker: checking concurrent data structures written with C/C++ atomics
First-class effect reflection for effect-guided programming
Characteristics of dynamic JVM languages
Constrained objects for modeling complex structures (extended abstract)
Proceedings of the 2020 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software, Onward! 2020, Virtual, November, 2020
CanonSketch and TaskSketch: innovative modeling tools for usage-centered design
A Framework for Visualizing Object-Oriented Systems
Interaction-based programming with classages
Metaclass Compatibility
Proceedings of the 2016 ACM SIGPLAN International Conference on Object-Oriented Programming, Systems, Languages, and Applications, OOPSLA 2016, part of SPLASH 2016, Amsterdam, The Netherlands, October 30 - November 4, 2016
xDIVA: a debugging visualization system with composable visualization metaphors
An Integrated Color Smalltalk-80 System
Stateless model checking with data-race preemption points
Principles, patterns, and techniques for designing and implementing practical fluent interfaces in Java
Measuring the usability and capability of App inventor to create mobile Applications
Designing a memory aid to support software developers
Learning CUDA: lab exercises and experiences
A screen-oriented representation for mobile applications
Logical Observable Entities
Usable live programming
A constraint-based architecture for local search
Efficient context sensitivity for dynamic analyses via calling context uptrees and customized memory management
The JikesXen Java server platform
Novel language syntax to enhance readability: white space, parameter sets, & control structures
Partial behavioral reflection: spatial and temporal selection of reification
Service orchestration patterns: graduating from state of the practice to state of the art
Reflections on reflection
Third international workshop on web APIs and services Mashups (Mashups'09)
Workshop on specification and design
A minimalist approach to framework documentation
The observer effect of profiling on dynamic Java optimizations
Reuse of Algorithms: Still a Challenge to Object-Oriented Programming
Inferred call path profiling
Devirtualization in LLVM
Parallel evaluation of a DSP algorithm using julia
SOAR: Smalltalk Without Bytecodes
OODLE: a prototype Object-Oriented Design Learning Environment
Stop the software architecture erosion: building better software systems