OOPSLA 2013 advance tech program up

50 papers...some of them are even related to objects (author/institution names elided for brevity):

  1. Input-Covering Schedules for Multithreaded Programs
  2. Data-Driven Equivalence Checking
  3. Efficient Context Sensitivity for Dynamic Analyses via Calling Context Uptrees and Customized Memory Management
  4. Inductive Invariant Generation via Abductive Inference
  5. Resurrector: A Tunable Object Lifetime Profiling Technique for Optimizing Real-World Programs
  6. Code Optimizations Using Formally Verified Properties
  7. CDSChecker: Checking Concurrent Data Structures Written with C/C++ Atomics
  8. Empirical Analysis of Programming Language Adoption
  9. River Trail: A Path to Parallelism in JavaScript
  10. Barrier Invariants: A Shared State Abstraction for the Analysis of Data-Dependent GPU Kernels
  11. Online-Feedback-Directed Optimizations for Parallel Java Code
  12. Octet: Capturing and Controlling Cross-Thread Dependences Efficiently
  13. Semi-Automatic Rename Refactoring for JavaScript
  14. Ball-Larus Path Profiling Across Multiple Loop Iterations
  15. Combining Concern Input with Program Analysis for Bloat Detection
  16. Detecting API Documentation Errors
  17. Set-Based Pre-Processing for Points-To Analysis
  18. Multiverse: Efficiently supporting distributed high-level speculation
  19. On-the-fly Detection of Instability Problems in Floating-Point Program Execution
  20. Taking Off the Gloves with Reference Counting Immix
  21. Do Developers Benefit from Generic Types? An Empirical Comparison of Generic and Raw Types in Java
  22. Bottle Graphs: Visualizing Scalability Bottlenecks in Multi-Threaded Applications
  23. Class Hierarchy Complementation: Soundly Completing a Partial Type Graph
  24. Storage Strategies for Collections in Dynamically Typed Languages
  25. Relaxed Separation Logic: A Program Logic for C11 Concurrency
  26. Turning Nondeterminism into Parallelism
  27. Isolation for Nested Task-Parallelism
  28. Forsaking Inheritance: Supercharged Delegation in DelphJ
  29. Python: The Full Monty; A Tested Semantics for the Python Programming Language
  30. Miniboxing: Improving the Speed to Code Size Tradeoff in Parametric Polymorphism Translations
  31. Effective Race Detection for Event-Driven Programs
  32. Efficient Concurrency-Bug Detection Across Inputs
  33. On-the-fly Capacity Planning
  34. The Latency, Accuracy, and Battery (LAB) Abstraction: Programmer Productivity and Energy Efficiency for Continuous Mobile Context Sensing
  35. Flexible Access Control Policies with Delimited Histories and Revocation
  36. Interacting with Dead Objects
  37. Refactoring with Synthesis
  38. Language Support for Dynamic, Hierarchical Data Partitioning
  39. Verifying Quantitative Reliability of Programs That Execute on Unreliable Hardware
  40. Object-Oriented Pickler Combinators and an Extensible Generation Framework
  41. Option Contracts
  42. Targeted and Depth-first Exploration for Systematic Testing of Android Apps
  43. Ironclad C++: A Library-Augmented Type-Safe Subset of C++
  44. Injecting Mechanical Faults to Localize Developer Faults for Evolving Software
  45. Guided GUI Testing of Android Applications with Minimal Restart and Approximate Learning
  46. Steering Symbolic Execution to Less Traveled Paths
  47. MrCrypt: Static Analysis for Secure Cloud Computations
  48. Synthesis Modulo Recursive Functions
  49. Bounded Partial-Order Reduction
  50. Fully Concurrent Garbage Collection of Actors in Many-Core Machines

Comment viewing options

Select your preferred way to display the comments and click "Save settings" to activate your changes.

Just for fun, let's compare

Just for fun, let's compare with OOPSLA 2003 (1993 in a sibling post):

  1. Regular Types for Active Objects
  2. Specifications and Their Use in Defining Subtypes
  3. Safe and Decidable Type Checking in an Object-Oriented Language
  4. Tools for the Development of Application-Specific Virtual Memory Management
  5. A Framework for Dynamic Program Analyzers
  6. Experiences Developing and Using an Object-Oriented Library for Program Manipulation
  7. CHARM++: A Portable Concurrent Object Oriented System Based On C++
  8. Highly Efficient and Encapsulated Re-use of Synchronization Code in Concurrent Object-Oriented Languages
  9. Ada 9X: From Abstraction-Oriented to Object-Oriented
  10. The Amadeus GRT - Generic Runtime Support for Distributed Persistent Programming
  11. Object Distribution in Orca using Compile-Time and Run-Time Techniques
  12. Object-Oriented Execution of OPS5 Production Systems
  13. Typing the Specialization Interface
  14. Strongtalk: Typechecking Smalltalk in a Production Environment
  15. Inheritance Modeled with Explicit Bindings: An Approach to Typed Inheritance
  16. On the Purpose of Object-Oriented Analysis
  17. Selector Table Indexing & Sparse Arrays
  18. Efficient Handling of Multiple Inheritance Hierarchies
  19. Object Fault Handling for Persistent Programming Languages: A Performance Evaluation
  20. GROOP: An Object-Oriented Toolkit for Animated 3D Graphics
  21. Visualizing the Behavior of Object-Oriented Systems
  22. Structural Active Object Systems for Simulation
  23. Roles for Composite Objects in Object-Oriented Analysis and Design
  24. Building and Maintaining Analysis-Level Class Hierarchies Using Galois Lattices
  25. Subject-Oriented Programming (A Critique of Pure Objects)

And 2003:

And 2003:

  1. Language-independent aspect-oriented programming
  2. Refactoring for generalization using type constraints
  3. Partial behavioral reflection: spatial and temporal selection of reification
  4. Applying traits to the smalltalk collection classes
  5. OOPAL: integrating array programming in object-oriented programming
  6. Automatic detection and repair of errors in data structures
  7. A first-class approach to genericity
  8. A comparative study of language support for generic programming
  9. Lightweight confinement for featherweight Java
  10. Dynamic metrics for java
  11. How java programs interact with virtual machines at the microarchitectural level
  12. Effectiveness of cross-platform optimizations for a java just-in-time compiler
  13. HydroJ: object-oriented pattern matching for evolvable distributed systems
  14. Relaxed MultiJava: balancing extensibility and modular typechecking
  15. MJ: a rational module system for Java and its applications
  16. Mostly concurrent garbage collection revisited
  17. An on-the-fly mark and sweep garbage collector based on sliding views
  18. Heap compression for memory-constrained Java environments
  19. Declaring and checking non-null types in an object-oriented language
  20. Object equality profiling
  21. Mark-copy: fast copying GC with less space overhead
  22. Ulterior reference counting: fast garbage collection without a long wait
  23. Connectivity-based garbage collection
  24. Saving the world from bad beans: deployment-time confinement checking
  25. Language support for lightweight transactions
  26. Lazy modular upgrades in persistent object stores

Onward! 2013 program

Is up here. Overview:

  • Usable Security as a Static Analysis Problem: Modeling and Reasoning About User Permissions in Social-Sharing Systems
  • Model-Based, Event-Driven Programming Paradigm for Interactive Web Applications
  • What’s Wrong with Git? A Conceptual Design Analysis
  • Usable Live Programming
  • Conversational Programming
  • Game Programming by Demonstration
  • User Model and System Model: The Yin and Yang in User-Centered Software Development
  • The Power of Interoperability: Why Objects Are Inevitable
  • KScript and KSWorld: A Time-Aware and Mostly Declarative Language and Interactive GUI Framework
  • Growing Solver-Aided Languages with Rosette
  • Building Connections between the Theories of Programming Languages and Physical Systems
  • One VM to Rule Them All
  • Content over Container: Object-Oriented Programming with Multiplicities

re: git

yesssssss. hope it covers all the things the rub me the wrong way. dvcs is nice but git isn't the holy grail, despite the # of people who think it is.

You can find the presenter's

You can find the presenter's work: gitless, on github. :)

Next generation programming enironments

We have four great papers related to next generation programming environments:

  • Usable live programming (my paper)
  • Conversational programming: this is Alexander Repenning's new work on AgentSheets. An earlier version of this work was presented in VL/HCC. The idea is quite cool: to add a notion of focus and speculation of options that could be taken to the programming environment.
  • Game Programming by demonstration. I saw a demo of this system when I visited the EPFL this summer; it is basically a tablet-based programming environment that combines coding with concrete direct example based code.
  • KScript and KSWorld: A Time-Aware and Mostly Declarative Language and Interactive GUI Framework. From our friends at Alan Kay's Viewpoints Research Institute.

Links for KScript and KSWorld

Links for KScript and KSWorld papers:

Making Applications in KSWorld by Yoshiki Ohshima, Aran Lunzer, Bert Freudenberg, Ted Kaehler; 17 pages

We report on our experiences in creating a GUI framework called KSWorld, which supports an interactive and declarative manner of application writing. The framework embodies direct manipulation, a high degree of loose coupling, and time-aware execution derived from Functional Reactive Programming (FRP). We also describe how a universal document editor was developed in this framework.

The fields, or slots, of graphical widgets in KSWorld are reactive variables. Definitions of such variables can be added or modified in a localized manner, allowing on-the-fly customization of the visual and behavioral aspects of widgets and entire applications. Thus the KSWorld environment supports highly exploratory application building: a user constructs the appearance interactively with direct manipulation, then attaches and refines reactive-variable definitions
to achieve the desired overall behavior.

We also show that the system scales up sufficiently to support a universal document editor. About 10,000 lines of code were needed to build the framework, the FRP evaluator, the document model and the editor, including the implementation of the special language created for KSWorld.

A report on KScript and KSWorld (same authors) 34 pages; no abstract