All Stories

  1. Does Task Complexity Moderate the Benefits of Liveness? A Controlled Experiment
  2. SpecTacles: Supporting Control Flow Comprehension of Software Developers in TLA+
  3. MµSE: Supporting Exploration of Software-Hardware Interactions Through Examples
  4. Broadening the View of Live Programmers
  5. Toward Studying Example-Based Live Programming in CS/SE Education
  6. Too Simple? Notions of Task Complexity used in Maintenance-based Studies of Programming Tools
  7. Structured Editing for All: Deriving Usable Structured Editors from Grammars
  8. Probe Log: Visualizing the Control Flow of Babylonian Programming
  9. Competitive Debugging: Toward Contests Promoting Debugging as a Skill
  10. Digital Crochet: Toward a Visual Language for Pattern Description
  11. Partial Parsing for Structured Editors
  12. Toward Understanding Task Complexity in Maintenance-Based Studies of Programming Tools
  13. Example Mining
  14. First-Class Concepts: Reified Architectural Knowledge Beyond Dominant Decompositions.
  15. Shortening Feedback Loops in a Live Game Development Environment
  16. First-class concepts: reifying architectural knowledge beyond the dominant decomposition
  17. Example-based live programming for everyone: building language-agnostic tools for live programming with LSP and GraalVM
  18. RTPTorrent
  19. Visual design for a tree-oriented projectional editor
  20. Three trillion lines: infrastructure for mining GitHub in the classroom
  21. Reading logic as code or as natural language text
  22. Babylonian-style Programming: Design and Implementation of an Integration of Live Examples into General-purpose Source Code
  23. Ambiguous, informal, and unsound: metaprogramming for naturalness
  24. Implementing Babylonian/S by Putting Examples Into Contexts
  25. Exploratory and Live, Programming and Coding
  26. Cross-cutting Commentary
  27. A soup of objects: convenience interfaces for accessing domain objects in a global object graph
  28. The exploration workspace: interleaving the implementation and use of plain objects in smalltalk
  29. Group-Based Behavior Adaptation Mechanisms in Object-Oriented Systems
  30. Designing a live development experience for web-components
  31. Living in your programming environment: towards an environment for exploratory adaptations of productivity tools
  32. Towards concept-aware programming environments for guiding software modularity
  33. Automatic Reuse through Implied Methods
  34. Exploratory Development of Data-intensive Applications
  35. Edit Transactions: Dynamically Scoped Change Sets for Controlled Updates in Live Programming
  36. Deducing classes: integrating the domain models of object-oriented applications
  37. Gramada: immediacy in programming language development
  38. How to Build a High-Performance VM for Squeak/Smalltalk in Your Spare Time
  39. Transaction Layers
  40. Compatibility layers for interface mediation at run-time
  41. Reactive object queries: consistent views in object-oriented languages
  42. How Live are Live Programming Systems?
  43. Columnar objects: improving the performance of analytical applications
  44. Drop drop