First Class Copy & Paste

I have posted a draft of my latest OOPSLA submission: First Class Copy & Paste. As always, comments are welcome.

I apologize that this paper is so hard to read. It is very technical and formal, and all about internals, not the user interface. I felt that I needed to precisely define how Subtext works, both for myself, and for others who want to try to do something similar. A secondary goal was to document the idea of hypothetical computation that is in the demo. I also added a cool new idea: transactional concurrency. But few people will wade through the technicalities to get to that part. I probably should write a more accessible paper about hypotheticals and transactional concurrency.

7 Replies to “First Class Copy & Paste”

  1. lose the source and drop the thread
    use the logic flow instead
    make your will in the computer
    give it to the executor

    Sad to see there is no other comments yet.
    My interest lies more in the design than in the editing of it, and i have thought of what you could do in a language with connected components and without the textflow.
    Another “mad coder” (he or she? Name Cleo Saulnier, but not a bit “girly”) has an idea called LBP or Logic Based Programming.
    It builds on losing the thread in the program and follow the logical flows instead.

    I have developed some ideas about objects to connect in the flows (data, code or pure logic)and elements of differents types to build the flows in, with a function, a behaviour and a interface, built by combining elements and possible to change by functions defined in definitions used by the elements (which have interfaces to all the systems that can use the definitions: Editor, Compiler and Sheduler/Runner (by example for events, reactions, wait states).
    With different types of elements (which you could define yourself) you could use different semantics for the flow, dataflow and state in the elements: Functional, Reactive, Process based, with transitions between multipel states, or Thread based, with ordered actions in a system with one state, and use them in all the systems, by example for editing and userinterface to the element, presentation of the design or userinterface with parser for specifying the function in a domain specific language.

  2. The paper is great. Everyone interested in theory of programming should read it *completely*. Im part of a (two-person) effort to come up with better and novel ways of computer programming and think you’re absolutely heading in the right direction. I wonder how distribution and nondeterminism fit into this. Good work & hopefully you will be releasing some code soon.

  3. Thanks for the comments Stefan. Distribution and nondeterminism are good questions. I have some general ideas, but feel that Subtext needs to mature more before I can really figure it out. The idea with distribution would be to have a global shared Subtext tree, with some form of distributed ownership-locking on disjoint subtrees. One form of nondeterminism is already present, in the proposed implementation of transaction execution, which can arbitrarily re-order pending transactions. Some explicit source of randomness is also needed – this is tricky because probabalistic programs need to appear deterministic when you are editing and testing them. So the random seed would have to be made a global parameter which can be changed between “runs”.

  4. Hi! I was just reading this paper(draft?) and I got to the section on how you drew inspiration from Self. I’m not even reading the full mathematics at this stage, but I felt that you’re probably right in saying inclusions are a more general or powerful form of Self’s copying operation. Anyhow, I was suddenly very intrigued because reading this somehow reminded me macros in LISP – a more general or powerful sort of function evaluation – perhaps similarly?

    What I’m thinking of is that with a function in lisp, all the arguments are evaluated before the function itself is evaluated, kind of like self’s copy copies data in a rather static way (and functions by implementation I think?). Macros add flexibility over functions by letting you specify how/when function arguments are evaluated – Which allows you to copy or modify the relationships which produce the terms, instead of evaluating them, and also writing meta-programs to modify your abstract syntax tree.

    Many questions really – Do you think it’s really analagous? (perhaps not…) Is it possible to emulate lisp macros with inclusions? Is meta-programming possible with this system? (I am guessing so, since the code is structured in the same way as the data – it is probably possible to modify the code? But the videos don’t reach into this territory yet.)

    I hope you find this viewpoint interesting, although it may be off-base, and would love to see a comment if you read this. 🙂

  5. Tim,

    Indeed metaprogramming is very much a goal of Subtext, though it is one of the many things I haven’t gotten to yet. Subtext tries to go beyond the idea of LISP in which code and data LOOK alike, to making them ACT alike. Macros involve complex combinations of compile-time and run-time evaluation. They also make debugging problematic. In Subtext, there is only edit-time, and all data is reactive and code-like.

    Metaprogramming is seeing a bit of a resurgence of late, with “Generative Programming”, “Software Factories”, and the rediscovery of Domain Specific Languages. Metaprogramming also features centrally in lightweight web frameworks like Rails. Someone recently asked what “Subtext on Rails” would look like. Maybe I should think about that.


  6. Pingback: madonna porn
  7. Pingback: hardcore gay

Comments are closed.