yusuke1997/dblp-id-title huggingface dataset:
DigitalAssets discoverer: automatic identification of reusable software components
Faith, hope, and love: an essay on software science's neglect of human factors
Emscripten: an LLVM-to-JavaScript compiler
Dictionary-based query recommendation for local code search
AutAT: an eclipse plugin for automatic acceptance testing of web applications
Towards best practices in implementing and operating for the cloud
Designed as designer
CATfood, a Code Authoring Tool
Coherent Models for Object-Oriented Analysis
Sal/Svm: an assembly language and virtual machine for computing with non-enumerated sets
Inlining-Benefit Prediction with Interprocedural Partial Escape Analysis
Obstacles in Object-Oriented Software Development
Exploring Largebess, Complexity and Scalability from the OOT Perspective (Panel)
The OO Software Development Process (Panel)
Conference on Object-Oriented Programming Systems, Languages, and Applications, OOPSLA 1988, San Diego, California, USA, September 25-30, 1988, Proceedings
Building software for sensor networks
Automating ad hoc data representation transformations
The good, the bad, and the ugly: three ways to use a semantic code query system
Directed synthesis of failing concurrent executions
Building JIT compilers for dynamic languages with low development effort
Modular typestate checking in concurrent Java programs
Textual modeling tools: overview and comparison of language workbenches
Centralizing clone group representation and maintenance
How can our publication models best serve our research? (panel)
An aspect-oriented generative approach
Object Oriented Approach to MLS Database Application Design (Panel)
Accelerating the creation of customized, language-Specific IDEs in Eclipse
Painless Panes for Smalltalk Windows
Fully concurrent garbage collection of actors on many-core machines
Semantics of RxJS
When Objects Collide: Experiences with Reusing Multiple Class Hierarchies
Cloudscape: language support to coordinate and control distributed applications in the cloud
From definitional interpreter to symbolic executor
Chaperones and impersonators: run-time support for reasonable interposition
Sifting Out the Gold
Intermedia: The Architecture and Construction of an Object-Oriented Hypermedia System and Applications Framework
Efficient software model checking of data structure properties
Generics-related refactorings in eclipse
Experiences using object data management in the real world
Experiences using an ODBMS for a high-volume internet banking system
UML4COP: UML-based DSML for context-aware systems
Using web corpus statistics for program analysis
An approach to compile configurable systems with #ifdefs based on impact analysis
To be precise: regression aware debugging
Scaling testing of refactoring engines
Storage combinators
Regression Test Selection for Java Software
Modular generics
jMock: supporting responsibility-based design with mock objects
Refactoring multicore applications towards energy efficiency
Analysis of a metamodel to estimate complexity of using a domain-specific language
Reverse-engineering user interfaces to facilitateporting to and across mobile devices and platforms
Pyrlang: a high performance Erlang virtual machine based on RPython
OTM: Applying Objects to Tasks
CLAM, yet another library for audio and music processing?
Refactoring Java generics by inferring wildcards, in practice
Migration to model driven engineering in the development process of distributed scientific application software
Language Support for Changeable Large Real Time Systems
A Static Type System for Message Passing
Faith, evolution, and programming languages: from Haskell to Java to links
The 9th OOPSLA workshop on domain-specific modeling
Hardware and software support for fine-grained memory access control and encapsulation in C++
DEMOS: a tool for declarative executable modeling of object-based systems
Ringer: web automation by demonstration
Using events to debug Java programs backwards in time
Highly Efficient and Encapsulated Re-use of Synchronization Code in Concurrent Object-Oriented Languages
A case for relativistic programming
Migration from deprecated API in Java
The Trellis Programming Environment
Virgil: objects on the head of a pin
DSM'14: the 14th workshop on domain-specific modeling
Aspect-oriented implementation method: progressive or non-progressive approach?
LaCasa: lightweight affinity and object capabilities in Scala
BeneFactor: a flexible refactoring tool for eclipse
Object recognition in the enterprise: structural and behavioral capabilities of patient-centered medical homes
2016 ACM International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software, Onward! 2016, Amsterdam, The Netherlands, November 2-4, 2016
Workshop: architecture in an agile world
Video-based requirements engineering for pervasive computing applications: an example of preventing water damage
The latency, accuracy, and battery (LAB) abstraction: programmer productivity and energy efficiency for continuous mobile context sensing
Performance analysis and optimization of the RAMPAGE metal alloy potential generation software
Standard-based strategy to assure the quality of the mobile software product
Natural language-guided programming
CUDACL+: a framework for GPU programs
Extending the ODMG Object Model with Composite Objects
Component visualization based on programmer's conceptual models (poster session)
Improving developers' confidence in test results of multi-threaded systems: avoiding early and late assertions
Microphase: an approach to proactively invoking garbage collection for improved performance
Integrating Information Retrieval and Domain Specific Approaches for Browsing and Retrieval in Object-Oriented Class Libraries
Proceedings of the 4th ACM SIGPLAN International Workshop on Meta-Programming Techniques and Reflection, META@SPLASH 2019, Athens, Greece, October 20, 2019
Multicodes: optimizing virtual machines using bytecode sequences
Object-Oriented Real-Time Language Design: Constructs for Timing Constraints
Lightweight Object-Oriented Shared Variables for Distributed Applications on the Internet
Maximal causality reduction for TSO and PSO
Architecture-Oriented Visualization
Memory efficient CRDTs in dynamic environments
How to achieve scalable fork/join on many-core architectures?
Edge chasing delayed consistency: pushing the limits of weak memory models
Educators' symposium
Lessons from the Battlefield
Evaluation and usability of programming languages and tools (PLATEAU)
Should software conferences respect software?
Modelling software processes: a focus on objectives
HydroJ: object-oriented pattern matching for evolvable distributed systems
Letters from the edge of an agile transition
CSI: crash scene investigation
Intermedia: A Case Study of the Differences Between Relational and Object-Oriented Database Systems
Visualizing the word structure of Java class names
Harnessing emergence for manycore programming: early experience integrating ensembles, adverbs, and object-based inheritance
Translating imperative code to MapReduce
Replacing phrase structure grammar with dependency grammar in the design and implementation of programming languages
The great J2EE vs. microsoft.NET shootout
Experience with CommonLoops
A laboratory for teaching object-oriented language and design concepts with teachlets
Jolt: lightweight dynamic analysis and removal of object churn
Panel: Experiences with Reusability
Finding application errors and security flaws using PQL: a program query language
Separation of powers in the cloud: where applications and users become peers
Experience report on the development of a specialized multi-view multi-stakeholder model-based engineering framework
Variant path types for scalable extensibility
Once upon a time, like never before: the challenge of telling the next story
The Semantics of Version Control
Modeling Security Requirements for Applications (Panel)
Issues in the Design of Object-Oriented Database Programming Languages
Java thin clients revisited: an architecture for responsive, live wireless applications
Combining object-oriented paradigm and controlled natural language for requirements specification
Benefits of session types for software development
Problem-Solution Mapping in Object-Oriented Design
Engineering and reusing stable atomic knowledge (SAK) patterns
6th workshop on virtual machines and intermediate languages (VMIL'12)
MetaEdit+: defining and using domain-specific modeling languages and code generators
Making RUP agile
The Design and Implementation of Distributed Smalltalk
Getting value for money from software architecture: a goldfish bowl
Tracing vs. partial evaluation: comparing meta-compilation approaches for self-optimizing interpreters
Roles of variables in object-oriented programming
2010 international workshop on foundations of object-oriented languages (FOOL'10): SPLASH/OOPSLA'10 workshop summary
Improving trace-based JIT optimisation using whole-program information
Application frameworks: how they become your enemy
The Performance of an Object-Oriented Threads Package
From 0 to 1, 169, 600 in 3 minutes: nine months of testing by the DevCreek team
Modelling infection scenarios - a fixed-price eXtreme programming success story
Non-software examples of software design patterns
Building a large-scale generic object model: applying the CYC upper ontology to object database development in Java
The SmaCC transformation engine: how to convert your entire code base into a different programming language
On the need to define community agreements for controlled experiments with human subjects: a discussion paper
A DSML for reversible transformations
A novice's process of object-oriented programming
Decentralized control of automatic guided vehicles: applying multi-agent systems in practice
Data Abstraction Mechanisms in SINA/ST
Implementing NetUnify.com using squeak
Optimizing Multi-Method Dispatch Using Compressed Dispatch Tables
Developing and evolving Java applications using coordination contracts
Patterns meta-specification and cataloging: towards knowledge management in software engineering
Phosphor: illuminating dynamic data flow in commodity jvms
Fast splittable pseudorandom number generators
A formal specification of Java TM class loading
CheckCell: data debugging for spreadsheets
Library-based model-driven software development with SugarJ
Detecting Defects in Object-Oriented Designs: Using Reading Techniques to Increase Software Quality
Patterns: Cult to Culture? - Panel Session
Linear capabilities for CHERI: an exploration of the design space
Software design as story telling: reflecting on the work of Italo Calvino
Agile management - an oxymoron?: who needs managers anyway?
How a Java VM can get more from a hardware performance monitor
Design of the Opportunistic Garbage Collector
Generative model transformer: an open source MDA tool initiative
Maintaining the Consistency of Class Libraries During Their Evolution
Testing with concepts and axioms in C++
Tools for enforcing and inferring reference immutability in Java
Using RESTful web-services and cloud computing to create next generation mobile applications
Coverage and Its Discontents
BON development tool
Execution privatization for scheduler-oblivious concurrent programs
Impulse-86: A Substrate for Object-Oriented Interface Design
A Study of Locking Objects with Bimodal Fields
VM-level memory monitoring for resolving performance problems
Optimization coaching: optimizers learn to communicate with programmers
Proceedings of the 2015 ACM SIGPLAN International Conference on Object-Oriented Programming, Systems, Languages, and Applications, OOPSLA 2015, part of SPLASH 2015, Pittsburgh, PA, USA, October 25-30, 2015
A visualization of the frame representation language
Metaclasses are First Class: the ObjVlisp Model
Seven software engineers as one mind
A Framework for Dynamic Program Analyzers
Integrating independent components with on-demand remodularization
An approach to building model driven enterprise systems in Nebras Enterprise Framework
Polymorphic system architecture summary
An improved algorithm for slicing machine code
Consensus-based mining of API preconditions in big code
Automated migration of build scripts using dynamic analysis and search-based refactoring
Babylscript: multilingual javascript
Alias annotations for program understanding
Status report on JSR-305: annotations for software defect detection
SPLASH 2010 workshop on flexible modeling tools
Misfits in abstractions: towards user-centered design in domain-specific languages for end-user programming
Distributed object-oriented programming with multiple consistency levels in ConSysT
Statik: an incremental compiler generator
Towards automated cross-language refactorings between Java and DSLs used by Java frameworks
Ruby refactoring plug-in for eclipse
Teaching Object-Oriented Programming with the KEE System
ACM SIGPLAN international workshop on programming language and systems technologies for internet clients: (PLASTIC 2011)
The artist in the computer scientist: more humanity to our research
Mobile security: challenges, tools, and techniques (panel)
Guidance for domain specific modeling in small and medium enterprises
When importless becomes meaningful
Using a recursive traversal algorithm with an active composite pattern in swing applications
Design and implementation of transactional constructs for C/C++
Preliminary Defect Data from the Iterative Development of a Large C++ Program
Making live programming practical by bridging the gap between trial-and-error development and unit testing
Issues in the Design and Documentation of Class Libraries
C♭: a new modular approach to implementing efficient and tunable collections
Spray: programming with a persistent distributed heap
A high-level view of Java applications
Probabilistic model for code with decision trees
Improving user experience by infusing web technologies into desktops
Keynote address - data abstraction and hierarchy
Active support for clone refactoring: a perspective
Declarative web-applications without server: demonstration of how a fully functional web-application can be built in an hour with only HTML, CSS & Javascript Library
Collaboration and telecollaboration in design
Combining concern input with program analysis for bloat detection
Foundations of path-dependent types
ORTS: a tool for optimized regression testing selection
MAS-ML: a multi-agent system modeling language
Proceedings of the 14th ACM SIGPLAN International Workshop on Virtual Machines and Intermediate Languages, VMIL 2022, Auckland, New Zealand, 5 December 2022
Companion of the 18th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications, OOPSLA 2003, October 26-30, 2003, Anaheim, CA, USA
Writing truly efficient smalltalk
Virtual Memory on a Narrow Machine for an Object-Oriented Language
Better science through art
Deployable probabilistic programming
Analyzing ultra-large-scale code corpus with boa
Performance explorer: understanding java application behavior
Oracle scheduling: controlling granularity in implicitly parallel languages
Constraint-based polymorphism in Cecil: towards a practical and static type system
Improving software development organizations with autochthony
River trail: a path to parallelism in JavaScript
Elephant 2000: a programming language based on speech acts
Security through extensible type systems
You can have it all: abstraction and good cache performance
Abstracting resource effects
Subject-Oriented Design: Towards Improved Alignment of Requirements, Design, and Code
An Object-Oriented Modeling Environment
Adding rigorous statistics to the Java benchmarker's toolbox
Statically scoped object adaptation with expanders
A snapshot of studio based learning: code reviews as a means of community building
The composition refactoring triangle (CRT) practical toolkit: from spaghetti to lasagna
Finding architectural flaws in android apps is easy
Type-based safe resource deallocation for shared-memory concurrency
Re-approaching the refactoring Rubicon
The Programming Language Wars: Questions and Responsibilities for the Programming Language Community
Finding minimum type error sources
Proceedings of the 8th International Workshop on Virtual Machines and Intermediate Languages, VMIL@SPLASH 2016, Amsterdam, The Netherlands, October 31, 2016
Systematic Software Reuse - Panel Session
Challenges: agile values meet different value systems
Multilingual distance learning for engineering
Generative model transformer
SPUR: a trace-based JIT compiler for CIL
Computational Reflection in Class-Based Object-Oriented Languages
Controlling Garbage Collection and Heap Growth to Reduce the Execution Time of Java Applications
A Formalism for Real-Time Concurrent Object-Oriented Computing
Model-driven development with predictable quality
Combining Contracts and Exemplar-Based Programming for Class Hiding and Customization
Interleaving of Modification and Use in Data-driven Tool Development
Change Cases: Use Cases that Identify Future Requirements
CallƐ: an effect system for method calls
Panel: Architectural Alternatives for Object-Oriented Database Management
Students' cooperation in teamwork: binding the individual and the team interests
The META4 programming language
A trace-based Java JIT compiler for large-scale applications
Automated backward error analysis for numerical code
One VM to rule them all
Symbolic and Spatial Database for Structural Biology
A language development environment for Eclipse
Proceedings of the 2012 ACM workshop on Relaxing synchronization for multicore and manycore scalability, RACES@SPLASH 2012, Tucson, Arizona, USA, October 21, 2012
Scalable, expressive, and context-sensitive code smell display
Workshop on OODB semantics
Cruisecontrol.rb: continuous integration the rails way
A FrameWork for high-performance image exploitation
Rethinking the human-readability infrastructure
Reality abstraction and OO pedagogy: results from 5 weeks in virtual reality
Poker: visual instrumentation of reactive programs with programmable probes
Three Steps to Views: Extending the Object-Oriented Paradigm
Improving usability of refactoring tools
Panel: Distributed Processing
Empirical investigation of the impact of extreme programming practices on software projects
Reflective Facilities in Smalltalk-80
Efficient Type Inclusion Tests
Type classes as objects and implicits
Checking API protocol compliance in java
Sonifying performance data to facilitate tuning of complex systems: performance tuning: music to my ears
East meets west: the influences of geography on software production
Pattern-based model transformation
Adaptive multi-level compilation in a trace-based Java JIT compiler
A simple model of agile software processes - or - extreme programming annealed
Statically typed string sanitation inside a python
Pure and declarative syntax definition: paradise lost and regained
Proceedings of the 1st International Workshop on Mobile Development, Mobile!@SPLASH 2016, Amsterdam, Netherlands, October 31, 2016
Parallel programming with object assemblies
Observing the Uptake of a Language Change Making Strings Immutable
Intermediate language design of high-level language virtual machines: towards comprehensive concurrency support
Monotonic Conflict Resolution Mechanisms for Inheritance
Use case and business rules: styles of documenting business rules in use cases
PowerPoint and complexity
Secure trade lane: a sensor network solution for more predictable and more secure container shipments
Emergent feature modularization
Use at your own risk: the Java unsafe API in the wild
Multiple instances and symbolic variables in executable sequence charts
How are programs found? speculating about language ergonomics with Curry-Howard
Challenges in transition from web to app
Perspectives on Reuse (Panel Session)
Automatic memory reclamation for lock-free data structures
Towards a framework for requirement change management in healthcare software applications
Staged program development
Semantic-based systems development
A Language for Specifying Recursive Traversals of Object Structures
XAspects: an extensible system for domain-specific aspect languages
Preparing undergraduate students for Java certification
Formal specification of a JavaScript module system
The 2nd workshop on human aspects of software engineering (HAoSE2010)
Panini: a capsule-oriented programming language for implicitly concurrent program design
NUMA-aware memory manager with dominant-thread-based copying GC
Generating chat bots from web API specifications
Proceedings of the 2014 International Workshop on Privacy & Security in Programming, Portland, OR, USA, October 21, 2014
Development of automatically verifiable systems using data representation synthesis
Boa: analyzing ultra-large-scale code corpus
"You have said too much": Java-like verbosity anti-patterns in Python codebases
The GMF-based syntax tool of a DSML for the semantic web enabled multi-agent systems
Young guns/object orientation: the next generation
Typelets
On creating a handbook of software architecture
Runtime metric meets developer: building better cloud applications using feedback
Exana: an execution-driven application analysis tool for assisting productive performance tuning
The mythical matched modules: overcoming the tyranny of inflexible software construction
Building Tailorable Hypermedia Systems: The Embedded-Interpreter Approach
Xtext: implement your language faster than the quick and dirty way
Harmony-oriented smalltalk
Dancing with uncertainty
FlashMeta: a framework for inductive program synthesis
The Kala Basket: A Semantic Primitive Unifying Object Transactions, Access Control, Versions, and Configurations
Homogeneous family sharing
Domain specific languages: another silver bullet?
A coordination methodology and technology for agile businesses
Object-Oriented Composition Untangled
Concurrency control for multithreaded reactive programming
Aiding programmers using lightweight integrated code visualization
The first international workshop on unified data mining engine: addressing challenges (UDME 2007)
Doing Business with Governments (Panel)
Understanding the interplay between task scheduling, memory and performance
How Mobile Affects Business Processes?: The Research Perspective
Workshop on compiling and optimizing
Acceptability-oriented computing
ArchMatE: from architectural styles to object-oriented models through exploratory tool support
Persistent Shared Object Support in the Guide System: Evaluation & Related Work
Ball-Larus path profiling across multiple loop iterations
Producing and delivering a coursera MOOC on pattern-oriented software architecture for concurrent and networked software
A Smalltalk Implementation of an Intelligent Operator's Associate
Virtual Copies - At the Boundary Between Classes and Instances
Supporting software evolution through model-driven program transformation
A variability-aware module system
Subtext: uncovering the simplicity of programming
Efficient implementation of the plaid language
mbeddr: an extensible C-based programming language and IDE for embedded systems
Towards a WebAssembly standalone runtime on GraalVM
Virtual machines with sharable operating system
The Java Syntactic Extender
Estimating software based on use case points
An architecture for the evolution of Web applications (poster session)
Scrap your boilerplate with object algebras
Strongtalk: Typechecking Smalltalk in a Production Environment
Silhouette: visual language for meaningful shape
Adaptive optimization in the Jalapeño JVM
Teaching and training developer-testing techniques and tool support
Efficient VM-independent runtime checks for parallel programming
A demonstration-based approach for designing domain-specific modeling languages
MELDing Data Flow and Object-Oriented Programming
Reusable C++ code for an electron-phonon simulation
Improving maintenance by creating a DSL for configuring a fieldbus
On-the-fly detection of instability problems in floating-point program execution
Scalable propagation-based call graph construction algorithms
Minimizing dependencies within generic classes for faster and smaller programs
The wonderful wizard of LoC: paying attention to the man behind the curtain of lines-of-code metrics