Posted on by Jonathan Edwards

Emerging Languages Camp Wrapup

I meant to write this earlier, but I have been occupied with a family medical emergency. The EL camp was a great experience, and I hope they do it again. I met more interesting people, and heard more interesting ideas, than at any other conference I have attended. Naturally there were ups and downs. There were some me-too languages with no purpose other than to entertain and glorify the author. But there were also quite a few serious efforts to try out new ideas and advance the state of the art. I would like to thank the organizers, Alex Payne and Brady Forrest, for perceiving the need and making this event happen.

I thought my talk was received pretty well. A video will supposedly be available shortly. Not everyone bought the motivating example as proof of the deep flaws of sequential programming. I definitely need some better examples. But nevertheless people seemed to appreciate my exploring some radical ideas, and respected the effort even if they didn’t fully embrace it. That was a good feeling, and quite the opposite of what I experience at academic conferences, where many people consider what I am doing not to be proper Computer Science. Actually they are right, but that is more an indictment of Computer Science than me. Which brings up the other outcome of the EL camp.

I spent most of my socializing time stirring up trouble. Computer Science is now so obsessed with rigorous evaluation that programming language research has become stultified. I found that a number of people agree with me, and wish there was something that could be done about it. The EL camp was a perfect place to foment insurrection. I don’t know where this is going, but I am going to keep rabble rousing and find out. Stay tuned – the revolution will be blogged.

19 Replies to “Emerging Languages Camp Wrapup”

    1. Hi Mac. I guess you’ve had some luck with that. I suppose I should try it out. The main problem I worry about is that most people working on PL’s largely ignore the SE literature, so I wouldn’t be communicating with them.

      1. SE people talk this strange language that us PL people can’t really understand or speak back. The only PL person that I think has successfully crossed over between PL and SE is Jonathan Aldrich (ArchJava). In the end, I think they are trying to solve different problems from us, they are thinking about software creation processes while we are looking more at the nuts and bolts of programming. They are definitely related, but I believe the SE problems are still very orthogonal to the PL problems and it still makes sense to pursue the problems separately.

        1. If you do a blekko search for “software engineering programming languages /people” you’ll get far more than just Jonathan Aldrich. I would name a few more, but the list is so overwhelming that just giving glimpses of it would be a disservice.

      2. Well, first, there is some overlap between the two communities. But, second, if some of your work belongs in SE, and the PL community just cannot see its significance, then the SE community is the one you’d want to talk to anyway. Different research communities can have some horribly myopia, and you’ve found a blind spot that applies to most of PL.

        1. It goes both ways, SE often doesn’t really get PL. At anyrate, if you are working on PL constructs, the PL community should be your home, not the SE community. If you are working on software engineering process advancements, then ya, SE, if you are working on programming constructs with direct SE relationships, then PL or SE is appropriate (ArchJava). Its not rocket science.

          1. Well, let me share some of my frank opinions.

            You could have a new programming construct aimed at improving modularity, which would make SE a better home for it. Previously, I would have said AOSD would be a good home for it too, but they shifted priorities too far (there is talk of making it good again, but, just as with the new SPLASH, I’m not holding my breath).

            But programming language design, which Jonathan does, is not found in PL conferences. It is found in SE conferences, or the crossovers like OOPSLA (circa the 90-00’s) and PASTE.

            SE has the risk of people frequently saying “that’s not science” or “that’s not research” but similarly uncharitable things have also been said about papers that introduce optimizations and show the results of several benchmarks that don’t model real-world applications very well.

            There is also talk of making conferences more conference-like again. They have become too conservative, rejecting new ideas in favor of incremental improvements that try to jam as much “rigor” in the form of 9pt Greek fonts as possible. [This problem plagues the social sciences and the humanities as well. A typical economics journal now looks like an advanced calculus textbook.]

          2. I’ve done the introduce new “modularity construct” before and have had good receptions in both OOPSLA and ECOOP. Language design isn’t dead in these conferences, or at least wasn’t 10 years ago :).

            I don’t believe ICSE or FSE would have been a good place for my work, though I could have probably had tailored papers for these conferences. Why? I relate much better to the old (and new) guard of the OOP community. OOP conferences used to be very good during their golden age (till about the late 90’s), and those people are still around, and they still provide great feedback.

            Concerning AOSD, the train wreck that are aspects is another issue: this is kind of why the community is weary of new language ideas now. Actually, its not that the community is not receptive to new language ideas, its that you’ve got to do a lot of thinking and fieldwork before they really want to hear about them.

  2. Shouldn’t we improve ourselves in all aspects?

    This is the way athletes train: resistance stretching, interval training, pylometrics…

    constantly confusing our muscles so that we increase our strength, speed, metabolism and endurance…

  3. Computer Science is not even a “Science” anyway, where is its scientific method? how does it determine what is good or true?

    Its all Computer Engineering.

    1. Scientific method is evident in engineering disciplines, and computation is integral to the scientific method itself. Most of the work being done at the forefront of physics, biology etc. is highly computationally intensive so seems to me that CS will inform a good deal of how natural science gets done in the future.

      1. Its still not a Science, Engineering is used in Science but that does not make it a Science.

        The fact is, in the computer we are God’s, we can change any bit to anything we desire but we turn the whole system into a bureaucratic universe which does not fit at all with what a God would prefer.

          1. Z-Bo, I have to side with Phillip here. I believe much of programming is properly seen as a form of Design (with a capital D), which is acknowledged in other fields as a practice distinct from Science, Math, or Engineering. The standard distinction is that while Science is about analyzing what exists, Design is about creating new things of human value. And while Engineering optimizes quantitative metrics, Design balances qualitative values.

  4. I’ve watched your talk with Charles ( http://channel9.msdn.com/posts/Charles/Jonathan-Edwards-Programming-Futures-and-Declarative-Objects/ ), which is very interesting. About the object tree model, you briefly explained (14:00-15:10): I think, indeed, that copying objects is a good idea. But only semantically. Practically; it explodes.

    What if there is a copy function that would return a “lazy copied object”? This way, the copying is only done when the copied object is really necessary (for instance, when performing an operation on the object).

    How do you think about variables in a “no pointers, only copies”-model? Is a variable a function from objects (the dependencies) to an object (the value)? A read operation is a function call? A write operation is a copy operation?

    When I say “yes” to all questions: e.g. the statement x = y, is a function-object x(y()), and it’s a child of the object given by the function y(). If you write to y, it means that the sub-tree of y() is copied and the returned object of y() is the same as the new “written” object to y. (The nulary function y() is a constant.)

    In your slides, you mention the start = end - length, end = start + length, length = end - start example. These can be written as functions:
    start(end(start(...), length(end(start(...), length(...)), start(...)), length(...)), etc. which is explosive.
    What when using lazy copying:
    start(copyl(end), copyl(length)), etc. The function representing a variable is copied very lazy. When one variable is written, thus the tree is copied for this first time, it wouldn’t make any sense (it leads to circular copying, i.e. self-copying). When two variables are written, and the tree is copied for a second time, it would make sense (no more circular copying). Because the lazy copy isn’t copying when it’s not used, it would not explode:

    Original: start(copyl(end), copyl(length)), end(copyl(start), copyl(length)), length(copyl(end), copyl(start)).
    First copy: start(copyl(end), copyl(length)), end(copyl(start), copyl(length)), length().
    Second copy: start(copyl(end), copyl(length)), end(), length().

    Using the start function upon the second copy works. It’s only a matter of finding out when the start function may be used. In this case, it may be used when there is no circular reference. (“may”: the tools from Subtext, where there is a “gap” or “overlap” case, can be extended by including a “hole” case (which means self-reference), will determine whether a function may be used)

    Problem: what if the start variable is written? It would result in an inconsistency in the structure. How to solve: immutable data structures. How to “update” an immutable data structure? Simply by creating a new one, based on the old one, e.g.:

    a_start = 5, a_length = 5;. (would calculate a_end = 10)
    b_start = a_start + 1, b_length = a_length. (where b_start is the function b_start(a_start()), etc.)

    My point with this latest example: statical analysis can show when structures are “valid”, when checking for “gaps”, “overlaps” and “holes” succeeds. Check whether a function calls itself isn’t hard.

    What do you think about this?

    1. Hans, I don’t completely understand your proposal, but it sounds similar to what I am doing. My semantics is based on value copying, where the values are subtrees. But behind the scenes these copies can be virtualized using standard copy-on-write techniques.

      1. Yes, we do think alike, but I don’t know how far you are in the process. So, I’m sorry if you believe what I am doing, trying to help you in your quest, is not appropriate.

        To illustrate my point, I’ve created two diagrams.

        The first, here, is a correct tree. It is a tree in “unknown”-state, “after copy”-state and “after side-effect”-state, respectively.

        The second, here, is an invalid tree which is fixed by an effect. The effect replaces the invalid subtree and lets the overall tree represent a value.

        The red parallelogram is an effect (mandatory) or side-effect (optional). It will also copy if the node it affects is copied. Parent nodes are affected by the side-effects of their children: the (side-)effect is chained until it has no more effect (for instance, a boolean that due to the effect changes from “true” to “true” will not chain further, as it has no effectiveness).

        My point: if a tree is invalid (“hole”, “gap”, “overlap”), then it’s not possible to have it represent a value. Invalid structures can be corrected (or initialized) by effects.

        I hope this helps you, in any way.

        (P.S. I laughed at WordPress because it thinks this is a spamming post)

      2. P.P.S. In the first tree, the middle group (captioned by “26”):

        What if a side-effect occurs on the “7” node of the copied subtree? Would copying imply a bidirectional binding? Or is a unidirectional binding better: as long the copied subtree is not modified, the copied tree is bound. A side-effect on the copy results in breaking the binding.

        Definition: X_original ? X_copy.

        t: (X_original: 5) => (X_copy: 5).
        t+n: (X_original: 9) => (X_copy: 9).
        t+n+m: (X_copy: 6).
        t+n+m+o: (X_original: 4).

        (Where the side-effect to X_original at t+n+m+o wouldn’t effect the X_copy)

    2. Hans, yes that is the way my model works, if I am understanding you. Further, the binding links themselves get copied, and are subject to incremental change. I have been promoting this data model for about 5 years now, in multiple papers, and so far have largely failed to get it across.

Comments are closed.