Catalog

This catalog highlights projects, people, groups, research, discussions, and other initiatives in the malleable software community. It is our hope that bringing more awareness to these efforts will lead to greater collaboration and better systems for us all that support the essential principles of malleability.

If you know of people, projects, threads, or anything else that should be added, please contribute or send us a note. Similarly, please let us know about anything that should be removed or corrected.

Order in the catalog is randomised on each page load.

Projects, papers, and discussions

  • Andrea A. diSessa Harold Abelson Boxer: a reconstructible computational medium. 1986.
      One major benefit of programmability is that even professionally produced items become changeable, adaptable, fragmentable, and quotable in ways that present software is not.
      … a reconstructible medium should allow people to build personalized computational tools and easily modify tools they have gotten from others. This concept is in strong contrast to the current situation in applications software — professionals are designing tools only for large populations with a common need.
      Boxer challenges, in a small way, the current view of programming languages. More significantly, it challenges the current view of what programming might be like, and for whom and for what purposes programming languages should be created. We have argued that some computer languages should be designed for laypeople, and have presented an image of how computation could be used as the basis for a popular, expressive, and reconstructible medium. Computers will become substantially more powerful instruments of educational and social change to the extent that such an image can be realized.
  • Geoffrey Litt Browser extensions are underrated: the promise of hackable software. 2019.
      Among major software platforms today, browser extensions are the rare exception that allow and encourage users to modify the apps that we use, in creative ways not intended by their original developers. On smartphone and desktop platforms, this sort of behavior ranges from unusual to impossible, but in the browser it’s an everyday activity.
      Since the beginning of personal computing, there’s been a philosophical tradition that encourages using computers as an interactive medium where people contribute their own ideas and build their own tools—authorship over consumption.
  • Allan MacLean Kathleen Carter Lennart Lövstrand Thomas Moran User-tailorable systems: pressing the issues with buttons. 1990.
      It is impossible to design systems which are appropriate for all users and all situations. We believe that a useful technique is to have end users tailor their systems to match their personal work practices. This requires not only systems which can be tailored, but a culture within which users feel in control of the system and in which tailoring is the norm.
      It is worth emphasising that we are interested here in skills required for tailoring. We do not intend to suggest that a ‘programmer’ is more skilled than a ‘worker’ in any absolute sense. If we were to focus on skills in the work domain, we would find that the worker was most skilled and the programmer least skilled.
      As a first step in growing a tailoring culture, we claim that it should be as easy to change the environment as it is to use it (clearly all changes one might want to make will not be so easy - but it is important that some should be).
      A remarkable amount of tailoring can be done by relying on buttons produced by other people. Buttons can be kept in documents and can be easily passed around by email, thus they are a tool for the user community to augment the Xerox Lisp environment by combining individual innovation and by sharing improvements with others. The fact that small-grain improvements can easily ‘diffuse’ throughout the user community is a powerful principle for supporting user-driven evolution of systems.
  • Bret Victor Josh Horowitz Luke Iannini Toby Schachman Paula Te Virginia McArthur Dynamicland. 2017 — present.
      Dynamicland is a communal computer, designed for agency, not apps, where people can think like whole humans.
      No normal person sees an app and thinks ‘I can make that myself.’ Or even ‘I can modify that to do what I actually need.’ Computational media in Dynamicland feels like stuff anyone can make. … A humane dynamic medium gently leads people down a path from playing, to crafting, to remixing, to programming.
      Dynamicland is an authoring environment, and everyone is an author. People make what they need for themselves. They learn through immersion. The true power of the dynamic medium — programmability — is for everyone.
  • Richard Stallman contributors GNU Emacs. 1976 — present.
      Extensible means that you can go beyond simple customization and create entirely new commands. New commands are simply programs written in the Lisp language, which are run by Emacs’s own Lisp interpreter. Existing commands can even be redefined in the middle of an editing session, without having to restart Emacs. Most of the editing commands in Emacs are written in Lisp; the few exceptions could have been written in Lisp but use C instead for efficiency. — GNU Emacs manual, Introduction
      Org can be used as a TODO lists manager and as a planner. Org is a great plain-text table editor. Org is an authoring and publication tool. Org makes literate programming a handy and natural way to deal with code. — Org mode feature list
      This appendix covers some areas where users can extend the functionality of Org. — Org mode manual, Appendix A Hacking
  • Ink & Switch End-user programming. 2019.
      Desktop programs, web apps, and smartphone apps are to various degrees like appliances with a hermetic seal to keep users out of their interior. If there is not already a button for a given function, the only option for users is to petition the developer.
      There shouldn’t be a chasm that the user has to cross in order to customize the behavior of their software. Going from using to inspecting to modifying the system should be a gradual process where each of the steps is small enough to be easily discoverable. The user should not need to switch to “programmer mindset” but instead stay within the context of the application. They can stay close to their work and their ideas.
  • feenk Glamorous Toolkit. 2017 — present.
    A development environment built on top of Pharo, a modern successor of Smalltalk.
      Glamorous Toolkit is the moldable development environment. It is a live notebook. It is a flexible search interface. It is a fancy code editor. It is a software analysis platform. It is a data visualization engine. All in one. And it is free and open-source under an MIT license.
      We want the environment to fit the context of the current system and when it does not, we want to be able to mold it live. This seemingly small change is transformational and can be utilized in many ways.
      Whatever is shown on the screen is rendered in one single rendering tree. No canvas in between. That means that all layouts are regular layouts, including the graph layouts and text-editor layouts. That means that text is made of regular elements. And that means that all elements can be combinable without imposing a technical limit.
  • Bill Atkinson Dan Winkler HyperCard team at Apple HyperCard. 1987 — 2004.
      HyperCard is a software erector set that lets non-programmers put together interactive information — Bill Atkinson, Computer Chronicles (1987)
      HyperCard’s biggest win was a very low entry threshold for those who wanted to build their own ‘stacks’ - combinations of user interface, code, and persistent data. There were plenty of examples to suggest ideas, and all the code was open for tweaking. — Tim Oren, A Eulogy for HyperCard (2004)
  • Stephen Kell (owner) J. Ryan Stinnett (contributor) liballocs. 2011 — present.
    Meta-level run-time services for Unix processes… a.k.a. dragging Unix into the 1980s
      Unix abstractions are fairly simple and fairly general, but they are not humane, and they invite fragmentation. By ‘not humane’, I mean that they are error-prone and difficult to experiment with interactively. By ‘fragmentation’, I mean they invite building higher-level abstractions in mutually opaque and incompatible ways (think language VMs, file formats, middlewares…). To avoid these, liballocs is a minimal extension of Unix-like abstractions broadly in the spirit of Smalltalk-style dynamism, designed to counter both of these problems.
  • Philip Tchernavskij Designing and Programming Malleable Software. 2019.
    In publication.
      The contemporary landscape of interactive software operates as a “designer-knows-best” model that gives users very few opportunities to change their software or to make different pieces of software work together as they see fit.
      I introduce malleable software as a design vision that reconstructs the goals of tailorable systems with pluralism as a guiding value. Malleable software is made up of interface elements untangled from the closed worlds of apps, which can be developed by different authors and (re-)combined by end users.
  • Stephen Kell The mythical matched modules: overcoming the tyranny of inflexible software construction. 2009.
      Conventional tools yield expensive and inflexible software. … I propose that a solution must radically separate the concern of integration in software: firstly by using novel tools specialised towards integration (the “integration domain”), and secondly by prohibiting use of preexisting interfaces (“interface hiding”) outside that domain.
      Placing high-level tool support for integration and adaptation close to the user, for example within web application mashup platforms and browser extensions has already led to added-value innovations which could not have been anticipated by the creators of the underlying software.
  • Yoshiki Schmitz Software as a “place”. 2019.
      What makes a piece of software a “place” vs a “tool” or an “appliance”? … I think some notion of limitlessness and nesting are necessary. [The feeling of a “place”] seems to come from some kind of limitlessness: Notion has infinite hierarchies, Figma has an infinite canvas. … This definition matters to me because appliances are static, but places can be occupied and changed. You can have memories and experiences in them. Things can grow in them. New stuff can emerge. Communities can form. I want more software to be like that.
  • Antranig Basman Philip Tchernavskij What Lies in the Path of the Revolution. 2018.
      We argue that a form of “digital serfdom” has rapidly grown up around us, where various important classes of artefacts, increasingly essential for everyday life, including participation in political and economic life, cannot be effectively owned by ordinary individuals.
      Many of the technological barriers to ownership, especially as regards software, can be seen as embedded in certain questions of “reuse” — one of the central affordances of ownership is the ability to transplant a thing from its original location to a different one, following the desires or person of the owner. For most kinds of software this is possible in only a crude way — an “application” can be installed on one machine rather than another — and with the rising prevalence of rental or cloud-based models for the deployment of software, it is decreasingly possible at all.
      If you find a piece of software that does something of value to you, it should be possible to make it your own. This implies that you can keep using it as part of the collection of tools you carry with you, in familiar contexts, or experiment with using it in novel contexts.
  • Alan Kay Dan Ingalls Adele Goldberg Learning Research Group of Xerox PARC Smalltalk. 1972 — present.
    A programming language and in-context development environment with powerful built-in tools like a class browser, object inspector, and debugger.
      The message is the most fundamental language construct in Smalltalk. Even control structures are implemented as message sends. — Wikipedia
      The late-bound, message-based interfaces of objects provide strong interposability properties: clients remain oblivious of the specific implementation they are talking to. In turn, this simplifies the customisation, extension or replacement of parts of a system, all of which can be rendered as interposition of a different object on the same client. — Stephen Kell, The operating system: should there be one? (2013)
  • Weiwei Hsu The “Space” of Computing. 2018.
    Our conception of “computing” has changed and continues to change. This work identifies dimensions that constitute the “space of computing”.
      Currently, only those who have a programming background or resources have the ability to create digital artifacts. This forces the rest of the world to be consumers, rather than creators or authors. When creating digital products, our conception of target audience is “users.” The notion of “users” sometimes assumes that their main goal is consuming instead of playing, creating, or conversing. What if the digital environment was inclusive enough for anyone to create? How can we provide the tools that will enable everyone to become authors?
  • Clemens N. Klokmose James R. Eagan Siemen Baader Wendy Mackay Michel Beaudouin-Lafon Webstrates: Shareable Dynamic Media. 2015.
      Webstrates offer a novel approach for creating shareable dynamic media that blur the distinction between documents and applications. Our vision requires software to be malleable by users, so they can appropriate documents and tools to meet individual needs; shareable among users, so they can collaborate on multiple aspects of the media; and distributable across heterogeneous devices and platforms.
      By sharing embedded code, behavior typically associated with application software can also be (collaboratively) manipulated, opening the way to novel possibilities for combining content, computation and interaction. Webstrates can be composed by embedding one webstrate within another, a process called transclusion [Nelson 1995], that lets users truly share, rather than copy, content.
  • Geoffrey Litt Daniel Jackson Wildcard: Spreadsheet-Driven Customization of Web Applications. 2020.
      In this paper, we present spreadsheet-driven customization, a technique that enables end users to customize software without doing any traditional programming. The idea is to augment an application’s UI with a spreadsheet that is synchronized with the application’s data. When the user manipulates the spreadsheet, the underlying data is modified and the changes are propagated to the UI, and vice versa.
      Generic tools are especially important for software customization, because a common barrier to customizing software is not having enough time [Mackay 1991]—it’s more likely that people will customize software frequently if they can reuse the same tools across many applications.
      One of the most interesting properties of spreadsheets is that users familiar with only a tiny sliver of their functionality (e.g., storing tables of numbers and computing simple sums) can still use them in valuable ways. This supports the user’s natural motivation to continue using the tool, and to eventually learn its more powerful features if needed [Nardi and Miller 1991].

People and groups

The Malleable Systems Collective is a virtual community where anyone can participate, and so there are no members per se. The following people and groups are some of the key actors in this space due to their work highlighted above, which has been collated through contributions to the catalog from the community.

  • Antranig Basman

    Raising the Floor - International
  • Clemens N. Klokmose

    Aarhus University
  • James R. Eagan

    Télécom Paris
  • Geoffrey Litt

    MIT
  • Weiwei Hsu

    California College of the Arts
  • Ink & Switch

  • J. Ryan Stinnett

    Collective organiser
  • Philip Tchernavskij

    OCAD University
  • Stephen Kell

    University of Kent
  • Yoshiki Schmitz


We welcome your feedback and contributions.