yusuke1997/dblp-id-title huggingface dataset:
A rewriting approach to the design and evolution of object-oriented languages
Sifting out the mud: low level C++ code reuse
The hiphop virtual machine
Types and program transformations
Supporting systems QoS design and evolution through model transformations
Wearable-based Mobile App for Decision Making: The Case of a Safe Workplace
RoleCast: finding missing security checks when you do not know what checks are
The operation recorder: specifying model refactorings by-example
Proceedings of the 3rd ACM SIGPLAN International Workshop on Programming Experience, PX/17.2, Vancouver, BC, Canada, October 23-27, 2017
Establishing object invariants with delayed types
Effective preparation for design review: using UML arrow checklist leveraged on the Gurus' knowledge
A user study for comparing the programming efficiency of modifying executable multimodal interaction descriptions: a domain-specific language versus equivalent event-callback code
Software tools research: a matter of scale and scope - or commoditization?
Naming anonymous javascript functions
Protocol-based verification of message-passing parallel programs
Interactive Visualization of Design Patterns Can Help in Framework Understanding
A comparative study of parallel sort algorithms
Empirical analysis of programming language adoption
Making frameworks work: a project retrospective
Guidance trees: a new programming paradigm for non-programmers
Programming with time: cyber-physical programming with impromptu
Programs as information
Naturalistic types
JavaScript: the used parts
BuddyCache: high-performance object storage for collaborative strong-consistency applications in a WAN
Research.js: Evaluating Research Tool Usability on the Web
Second generation web services-oriented architecture in production in the finance industry
The need for richer refactoring usage data
Mining the Ecosystem to Improve Type Inference for Dynamically Typed Languages
Humane representation of thought: a trail map for the 21st century
A WYSIWYG approach for configuring model layout using model transformations
Bringing low-level languages to the JVM: efficient execution of LLVM IR on Truffle
A model-based method for seamless web and mobile experience
An architecturally-evident coding style: making your design visible in your code
Design pattern implementation in Java and aspectJ
Ninth OOPSLA workshop on behavioral semantics (poster session)
Extracting a domain specific language from an example: a bottom-up method using the ngrease metalanguage
Presenting a day in the life of video-based requirements engineering
9th workshop on parallel/high-performance object-oriented scientific computing
Beam: a virtual machine for handling millions of messages per second (invited talk)
Experimental Classification Facilities for Smalltalk
A lock-free cache invalidation protocol for the atom system
Models for forms
Symmetric distributed applications
Reflections and retrospectives in software development environments
JRefleX: towards supporting small student software teams
Example centric programming
Using dependency models to manage complex software architecture
A Parameterized Type System for Race-Free Java Programs
Beyond native apps: web technologies to the rescue! (keynote)
Software objects fairy tales: merging design and runtime objects into the cloud with mydraft
Proceedings of the International Workshop on Domain-Specific Modeling, DSM@SPLASH 2016, Amsterdam, Netherlands, October 30, 2016
An experimental survey of energy management across the stack
Analyzing the use of interfaces in large OO projects
Debug all your code: portable mixed-environment debugging
A Base for Secure Object Oriented Environments
Constraint Patterns As a Basis for Object-Oriented Programming
Model-based DSL frameworks
Answering control flow questions about code
The garbage collection advantage: improving program locality
Making Pure Object-Oriented Languages Practical
GLORP: generic lightweight object-relational persistence
10 years of Dart (invited talk)
Demystifying model transformations: an approach based on automated rule inference
Concurrency, Synchronization, and Scheduling to Support High-Assurance Write-Up in Multilevel Object-Based Computing
To pull or not to pull
Ageing society
Processing heterogeneous abstract syntax trees with the mutable class pattern
Tracking human-centric controlled experiments with biscuit
How java programs interact with virtual machines at the microarchitectural level
Migration and execution of JavaScript applications between mobile devices and cloud
On the benefits and pitfalls of extending a statically typed language JIT compiler for dynamic scripting languages
Fine-grained interoperability through mirrors and contracts
Angelic and demonic visitation: school memories
An analyzable annotation language
Cross-ISA debugging in meta-circular VMs
Managing ambiguity in programming by finding unambiguous examples
Second ACM workshop on hot topics in software upgrades (HotSWUp 2009)
Proceedings of the 11th ACM SIGPLAN International Workshop on Tools for Automatic Program Analysis, TAPAS@SPLASH 2020, Virtual Event, USA, November 17, 2020
A UML profile for service oriented architectures
Automated debugging in Eclipse (at the touch of not even a button)
AGERE!: programming based on actors, agents, and decentralized control
Clinical trial remote data capture client/server solution
Implementing a language with explicit assignment semantics
What is wrong with the software development?: research trends and a new software engineering paradigm
PAD: a pattern-driven analysis and design method
Documenting Frameworks using Patterns
Extracting implicit contracts from .NET libraries
GME: the generic modeling environment
iXj: interactive source-to-source transformations for java
The elephant in the room: who will take care of the code?
Swamp: A Fast Processor for Smalltalk-80
Declarative Programming in a Prototype-Instance System: Object-Oriented Programming Without Writing Methods
Language-independent aspect-oriented programming
Improving the usability of Eclipse for novice programmers
The dark side of agile software development
An approach and tools to automate externalization of application logic
Type Feedback vs. Concrete Type Inference: A Comparison of Optimization Techniques for Object-Oriented Languages
Safe and atomic run-time code evolution for Java and its application to dynamic AOP
Code optimizations using formally verified properties
abc the aspectBench compiler for aspectJ a workbench for aspect-oriented programming language and compilers research
greenfoot: combining object visualisation with interaction
Virtual Images: Interactive Visualization of Distributed Object-Oriented Systems
Advanced refactorings in eclipse
A Diagram for Object-Oriented Programs
Slicing Class Hierarchies in C++
Object Views: Language Support for Intelligent Object Caching in Parallel and Distributed Computations
Making trace monitors feasible
An Exemplar Based Smalltalk
Model-driven separation of concerns for service robotics
Talk versus work: characteristics of developer collaboration on the jazz platform
The Security Facilities of PCTE
The moldable inspector
Killer Applications for Mobile: Opportunity and Challenges Report Activity
Squirrel: an extensible distributed key-value store
OOPSLA'06 workshop outline: 1st workshop on model-based testing and object-oriented systems (M-TOOS)
Companion to the 25th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications, OOPSLA 2010, part of SPLASH 2010, October 17-21, 2010, Reno/Tahoe, Nevada, USA
R-Rio (poster session): reflective-reconfigurable interconnectable objects
Deducing classes: integrating the domain models of object-oriented applications
Making SOA work in a healthcare company
Peer code review in open source communitiesusing reviewboard
Optimization of distributed, object-oriented systems (poster session)
Beyond expert-only parallel programming?
Bounded partial-order reduction
Heterogeneous device hopping: bridging the mobile cross-platform gap via a declarative query language
Living with legacy: love it or leave it?
Putting the semantics into semantic versioning
Encoding the building blocks of communication
jStar: towards practical verification for java
Classifying and sharing O-O course materials reuse in the classroom
Scalable verification of border gateway protocol configurations with an SMT solver
Fast Dispatch Mechanisms for Stock Hardware
Concurrency Annotations
Language-specific make technology for the Java programming language
Molecule: using monadic and streaming I/O to compose process networks on the JVM
Java paradigms for mobile agent facilities
No name: just notes on software reuse
OO design methodology of a DSL using EMF: (demonstration for the telco revenue assurance domain)
Multiverse: efficiently supporting distributed high-level speculation
Methodology to develop domain specific modeling languages
The Role of Methods and CASE in OO Development (Panel)
Towards flexible and efficient model-based testing, utilizing domain-specific modelling
Type soundness for dependent object types (DOT)
SelfSync: a dynamic round-trip engineering environment
Valor: efficient, software-only region conflict exceptions
Investigation of error notifications through categorization
"Killer examples" for design patterns: a poster reporting results of the workshop
Minimizing Row Displacement Dispatch Tables
Smart play-out
MobileDeli'14 workshop: welcome message of the chairs
Extending the Operating System to Support an Object-Oriented Environment
If i had a model, i'd model in the mornin'
CORBA and the WWW
The storyteller version control system: tackling version control, code comments, and team learning
Modeling and analysis of remote memory access programming
Scalable comparison of JavaScript V8 bytecode traces
Towards checkpoint placement for dynamic memory allocation in intermittent computing
Towards a formalization for COM part i: the primitive calculus
Introducing patterns (or any new idea) into organizations (poster session)
Onward! 2014, Proceedings of the 2014 ACM International Symposium on New Ideas, New Paradigms, and Reflections on Programming & Software, part of SPLASH '14, Portland, OR, USA, October 20-24, 2014
ContextBox (extended abstract) (poster session): a visual builder for context beans
Panini: a concurrent programming model with modular reasoning
Proceedings of 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
IAnticorruption: a domain-driven design approach to more robust integration
Incremental Distribution of Timestamp Packets: A New Approach to Distributed Garbage Collection
Why programming is a good medium for expressing poorly understood and sloppily formulated ideas
Using metaphors with software teams
Design considerations for a cyber-physical testing language on the example of autonomous driving
Type systems for the masses: deriving soundness proofs and efficient checkers
Analogy-making as a Core primitive in the software engineering toolbox
So we thought we knew money
Improving quality in conceptual modeling
Reusing legacy DSLs with Melange
Proceedings of the 20th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications, OOPSLA 2005, October 16-20, 2005, San Diego, CA, USA
First-class state change in plaid
Synthesizing method sequences for high-coverage testing
Inferring aliasing and encapsulation properties for java
Languages of the future
Time Conscious Objects
System Support for Object Groups
Ownership and immutability in generic Java
From OO to FPGA: fitting round objects into square hardware?
Migrating to simpler distributed applications
Bloqqi: modular feature-based block diagram programming
Painting Multiple Views of Complex Objects
Teaching polymorphism with elementary design patterns
Class Modification in the GemStone Object-Oriented DBMS
MetaDL: declarative program analysis for the masses
Safe parallel programming using dynamic dependence hints
Banquet speech - objects and other subjects
Unsticking the web
WOSC 2014: second workshop on optimizing stencil computations
Industrial experiences with the evolution of a DSL
Refactoring support for class library migration
Refactoring: to the rubicon... and beyond!
Region-based memory management for GPU programming languages: enabling rich data structures on a spartan host
MDSD for the iPhone: developing a domain-specific language and IDE tooling to produce real world applications for mobile devices
BCNC 2021: Proceedings of the 1st ACM SIGPLAN International Workshop on Beyond Code: No Code, Virtual Event / Chicago, IL, USA, October 17, 2021
Regular Types for Active Objects
Giga-scale exhaustive points-to analysis for Java in under a minute
MJ: a rational module system for Java and its applications
The Javaputer: Java programming in a MOO
Grammar-driven generation of domain-specific language testing tools
Improving CRC-card role-play with role-play diagrams
Debugging and testing behavioral UML models
Computer-assisted specification of asynchronous interfaces with non-deterministic behavior
Design pattern density defined
Efficient dynamic analysis of the synchronization performance of Java applications
FlashFreeze: low-overhead JavaScript instrumentation for function serialization
Developing Software for Large-Scal Reuse (Panel)
The Oprop verification tool: object propositions in action
The open authorial principle: supporting networks of authors in creating externalisable designs
Constraint Diagrams: Visualizing Assertions in Object-Oriented Models
JQuery: finding your way through tangled code
Metamodel evolution through metamodel inference
A workbench for quality based software re-engineering (Doctoral Symposium)
OO techniques applied to a real-time, embedded, spaceborne application
Some were meant for C: the endurance of an unmanageable language
Scopira: an open source C++ framework for biomedical data analysis applications -- a research project report
Safely evolving configurable systems
Refactoring support for the groovy-eclipse plug-in
An experiment in teaching innovation in software engineering: video presentation
Self type constructors
Collaboration and communication: growing and sustaining ultra large scale (ULS) systems
The concern manipulation environment [OOPSLA/GPCE]
The JavaScript world domination plan at 16 years
Refactoring references for library migration
The OT Life-cycle: From Eureka! to Shrink Wrap (Panel)
Extensible visual constraint language
A type and effect system for deterministic parallel Java
Adaptive object-models (poster session)
AF-Raf: an agent-oriented programming language with algebraic data types
What programmers say about refactoring tools?: an empirical investigation of stack overflow
A Performance Comparison of Object and Relational Databases Using the Sun Benchmark
Ontology-driven software engineering
A security oriented program transformation to "add on" policies to prevent injection attacks
fmp and fmp2rsm: eclipse plug-ins for modeling features using model templates
Aspects and/versus modularity the grand debate
Is functional programming better for modularity?
Pattern specification and application in metamodels in ecore
Shiranui: a live programming with support for unit testing
Exploring cheap type inference heuristics in dynamically typed languages
What is a programming language, really?
Rate types for stream programs
Bidirectional Object Layout for Separate Compilation
Transparent Forwarding: First Steps
OO Anthropology: Crossing the Chasm (Panel Session)
AC: composable asynchronous IO for native languages
Workflow enactment with continuation and future objects
Portable serialization of CORBA objects: a reflective approach
Towards xMOF: executable DSMLs based on fUML
Empirical performance study of speculative parallel processing on commercial multi-core CPU with hardware transactional memory
Model driven architecture: how far have we come, how far can we go?
Towards moldable development tools
Object-Oriented Programming: An Objective Sense of Style
Identifying Barriers to Adoption for Rust through Online Discourse
Sizing multi-space in heap for application isolation
The 2nd workshop on refactoring tools (WRT'08)
Object-Oriented Security in the Trusted Mach TM Operating System
Viser: providing serializability in hardware with simplified cache coherence
LattesMiner: a multilingual DSL for information extraction from lattes platform
An On-the-Fly Reference Counting Garbage Collector for Java
How lock contention affects energy use in a CMP server
Annotating Objects for Transport to Other Worlds
The dynamics of changing dynamic memory allocation in a large-scale C++ application
Proceedings of the 2013 ACM workshop on Domain-specific modeling, DSM@SPLASH 2013, Indianapolis, Indiana, USA, October 27, 2013
A simple edit-time metaobject protocol: controlling the display of metadata in programs
Foundation: a model for concurrent project development
Static analysis of component systems using behavior protocols
Conscientious software
An Object Addressing Mechanism for Statically Types Languages with Multiple Inheritance
Ready for distribution?: turning modular into distributed applications with the R-OSGi deployment tool
Model synchronization as a problem of maximizing model dependencies
Hop: a language for programming the web 2.0
When refactoring acts like modularity: keeping options open with persistent condition checking
Incremental development of a repository-based framework supporting organizational inquiry and learning: Reflections on building a reflective framework
Empirical Comparison of Visual to Hybrid Formula Manipulation in Educational Programming Languages for Teenagers
Prototype-Based Languages: From a New Taxonomy to Constructive Proposals and Their Validation
How are programming questions from women received on stack overflow? a case study of peer parity
A protocol for scalable distributed concurrency services
Transformation of Data Flow Analysis Models to Object-Oriented Design
BOF on inheritance
MOF to EMF: there and back again
Structured statistical syntax tree prediction
Virtual Classes: A Powerful Mechanism in Object-Oriented Programming
Allocation wall: a limiting factor of Java applications on emerging multi-core platforms
From Events to Objects: The Heresy of Event-Orientation in a World of Objects (Panel)
Awesome: an aspect co-weaving system for composing multiple aspect-oriented extensions
Alternative programming interfaces for alternative programmers
Learning CUDA: lab exercises and experiences, part 2
Application isolation in the Java TM Virtual Machine
LCSD: library-centric software design
BoBs: breakable objects
DROL: An Object-Oriented Programming Language for Distributed Real-Time Systems
The Future of Distributed Object Computing - Panel Session
Finding deep compiler bugs via guided stochastic program mutation
Relations as Semantic Constructs in an Object-Oriented Language
Democratizing the cloud
An Access Control Model or a Parallel Object-Based Programming Language
Eberos GML2D: a graphical domain-specific language for modeling 2D video games
Integrated simulation of CIF3 and simulink models
Integrating an Object-Oriented Programming System with a Database System
The Design and Implementation of ConcurrentSmalltalk
Relooper: refactoring for loop parallelism in Java
Encapsulating Objects with Confined Types
Hardware/software codesign in neo smalltalk
Proceedings of the 13th International Workshop on Dynamic Analysis, WODA@SPLASH 2015, Pittsburgh, PA, USA, October 26, 2015
Automated assessment of students' testing skills for improving correctness of their code
Formal refactorings for object models
Designing croquet's TeaTime: a real-time, temporal environment for active object cooperation
Unipycation: a case study in cross-language tracing
Building an object relational database access layer
Exploring the acceptability envelope
Lessons from the Experiences of Leading-Edge Object Technology Projects in Hewlett Packard
On Objects and Events
Simulation-based code duplication for enhancing compiler optimizations
Persistent contextual values as inter-process layers
Proceedings of the 2014 ACM International Conference on Object Oriented Programming Systems Languages & Applications, OOPSLA 2014, part of SPLASH 2014, Portland, OR, USA, October 20-24, 2014
Client-aware checking and information hiding in interface specifications with JML/ajmlc
Self-designing software
Extensible access control with authorization contracts
Reducing parallelizing compilation time by removing redundant analysis
Gaining insight into programs that analyze programs: by visualizing the analyzed program
Concrete syntax for objects: domain-specific language embedding and assimilation without restrictions
Towards best practices in designing for the cloud
A sound and optimal incremental build system with dynamic dependencies
Precise software documentation: making object-orientation work better
Next-paradigm programming languages: what will they look like and what changes will they bring?
SOS: saving time in dynamic race detection with stationary analysis
Refactoring tool challenges in a strongly typed language (poster session)
Quantifying the performance of garbage collection vs. explicit memory management
Refactoring towards the good parts of javascript
YJIT: a basic block versioning JIT compiler for CRuby
XSnippet: mining For sample code
SPLASH'12 - Proceedings of the 2012 ACM Conference on Systems, Programming, and Applications: Software for Humanity, Tucson, AZ, USA, October 21-25, 2012
Visualizing Objects: Methods for Exploring Human Computer Interaction Concepts
The habanero multicore software research project
An Environment for Literate Smalltalk Programming
NOAO imaging meta data quality improvement: a case study of the evolution of a service oriented system
A study of Java's non-Java memory
VET3D: a tool for execution trace web 3D visualization
Towards transitory encapsulation
Improving live debugging of concurrent threads
FLOREnce: A Hybrid Logic-Functional Reactive Programming Language
Components on the Internet (Panel Session)
A portable javascript thread library for Ajax applications
Implicit constraints in partial feature models
Translation: Myth or Reality? (Panel Session)
Java type inference is broken: can we fix it?
ProfessorJ: a gradual introduction to Java through language levels
Multitasking without Compromise: A Virtual Machine Evolution
API analytics for curating static analysis rules
Integrating models with domain-specific modeling languages
SODA: a stability-oriented domain analysis method
Abstract semantic differencing via speculative correlation
Tool-box frameworks - the new challenge beyond black-box and white-box
Semantic software engineering tools
BrouHaHa - A Portable Smalltalk Interpreter
Enhancing locality for recursive traversals of recursive structures
Using compiler snippets to exploit parallelism on heterogeneous hardware: a Java reduction case study
Teaching OO methodology in a project-driven CS2 course
Integrating Object-Oriented Technolgy and Security Technology: A Panel Discussion
Smalltalk standardization efforts
Introducing computer science with Project Hoshimi
Evaluation of coupling in the context of Java interfaces (poster session)
Pocket code: a scratch-like integrated development environment for your phone
A HIP and SLEEK verification system
OOP in Languages Providing Strong, Static Typing (Panel)
Fine-grained test case prioritization for integration testing of delta-oriented software product lines
Designing immersive virtual training environments for experiential learning
Model-driven software product lines
Persistent Storgage for a Workflow Tool Implemented in Smalltalk
Automated recommendations for reducing unnecessary variability of technology architectures
Gradual typing for first-class classes
Towards a framework for the general intensional programming compiler in the GIPSY
Understanding communication within pair programming
A framework to enable user directed component binding at run-time
Registration-based language abstractions
Conversational programming: exploring interactive program analysis
Decompile Java class files with soot! (poster session)
Living structure and the software garden