Re: [fonc] LightTable UI
You make it sound a bit like this was a working solution already, while it seems to be a prototype at best, they are collecting funding right now: http://www.kickstarter.com/projects/306316578/light-table. I would love to be proven wrong, but I think given the state of the project, many people overexcite over it: some of the things proposed aren't new, just wrapped into a nice modern design (you could try to create a new skin or UI toolkit for some Smalltalk IDE for a similiar effect), while for the ones that would be new like the real-time evaluation or visualisation there is too little detail to say whether they are onto something or not - I am sure many people thought of such things in the past, but it is highly questionable to what extent those are actually doable, especially in an existing language like Clojure or JavaScript. I am not convinced if dropping 200,000$ at the thing will help with coming up with a solution if there is no decent set of ideas to begin with. I would personally be much more enthusiastic if the people behind the project at least outlined possible approaches they might take, before trying to collect money. Currently it sounds like they just plan to hack it until it handles a reasonable number of special cases, but tools that work only some of the time are favoured by few. I think we need good theoretical approaches to problems like this before we can make any progress in how the actual real tools work like. Cheers, Jarosław Rzeszótko 2012/4/24 Julian Leviston jul...@leviston.net Thought this is worth a look as a next step after Brett Victor's work ( http://vimeo.com/36579366) on UI for programmers... http://www.kickstarter.com/projects/ibdknox/light-table We're still not quite there yet IMHO, but that's getting towards the general direction... tie that in with a tile-script like language, and I think we might have something really useful. Julian ___ fonc mailing list fonc@vpri.org http://vpri.org/mailman/listinfo/fonc ___ fonc mailing list fonc@vpri.org http://vpri.org/mailman/listinfo/fonc
Re: [fonc] LightTable UI
I'm pretty much in agreement with you about all your points. I just thought it was worth a look, as I said. Julian On 24/04/2012, at 5:50 PM, Jarek Rzeszótko wrote: You make it sound a bit like this was a working solution already, while it seems to be a prototype at best, they are collecting funding right now: http://www.kickstarter.com/projects/306316578/light-table. I would love to be proven wrong, but I think given the state of the project, many people overexcite over it: some of the things proposed aren't new, just wrapped into a nice modern design (you could try to create a new skin or UI toolkit for some Smalltalk IDE for a similiar effect), while for the ones that would be new like the real-time evaluation or visualisation there is too little detail to say whether they are onto something or not - I am sure many people thought of such things in the past, but it is highly questionable to what extent those are actually doable, especially in an existing language like Clojure or JavaScript. I am not convinced if dropping 200,000$ at the thing will help with coming up with a solution if there is no decent set of ideas to begin with. I would personally be much more enthusiastic if the people behind the project at least outlined possible approaches they might take, before trying to collect money. Currently it sounds like they just plan to hack it until it handles a reasonable number of special cases, but tools that work only some of the time are favoured by few. I think we need good theoretical approaches to problems like this before we can make any progress in how the actual real tools work like. Cheers, Jarosław Rzeszótko 2012/4/24 Julian Leviston jul...@leviston.net Thought this is worth a look as a next step after Brett Victor's work (http://vimeo.com/36579366) on UI for programmers... http://www.kickstarter.com/projects/ibdknox/light-table We're still not quite there yet IMHO, but that's getting towards the general direction... tie that in with a tile-script like language, and I think we might have something really useful. Julian ___ fonc mailing list fonc@vpri.org http://vpri.org/mailman/listinfo/fonc ___ fonc mailing list fonc@vpri.org http://vpri.org/mailman/listinfo/fonc ___ fonc mailing list fonc@vpri.org http://vpri.org/mailman/listinfo/fonc
Re: [fonc] LightTable UI
On Tue, Apr 24, 2012 at 12:32 PM, Jarek Rzeszótko jrzeszo...@gmail.comwrote: On the other hand, *Those who cannot remember the past are condemned to repeat it.* Or perhaps, *It's critical to recover, reimagine, and communicate the great ideas past before they are completely forgotten* * * Yes, there are few ideas here that haven't been explored in some form - Smalltalk / Squeak come immediately to mind. Yet Smalltalk / Squeak still don't have much in the way of real reach. Chris Granger is taking some of these great ideas and putting them into a package that working programmers actually care about - JavaScript development. That he is smuggling in Lisp is just icing on the cake. It takes money and time to develop grand ideas. Failure is ok. David ___ fonc mailing list fonc@vpri.org http://vpri.org/mailman/listinfo/fonc
Re: [fonc] LightTable UI
Benjamin Pierce et al did some work on bidirectional computation. The premise is to work with bidirectional transformations (which they call lenses) rather than (unidirectional) functions. They took a stab at identifying some primitives, and showing how they would work in some applications. Of course we can do all the composition tricks with lenses that we can do with functions :) http://www.seas.upenn.edu/~harmony/ See also Gerald Sussman's essay Building Robust Systems, http://groups.csail.mit.edu/mac/users/gjs/6.945/readings/robust-systems.pdf In particular, he has a section called Constraints Generalize Procedures. He gives an example of a system as a constraint solver (two-way information flow) contrasted with the system as a procedure (one-way flow). Also I submitted a paper for Onward 2012 which discusses this topic among other things, http://totem.cc/onward2012/onward.pdf My own interest is in programming interfaces for artists. I am interested in these causally agnostic programming ideas because I think they could support a more non-linear, improvisational approach to programming. Toby 2012/4/24 Jarek Rzeszótko jrzeszo...@gmail.com: On the other hand, Those who cannot remember the past are condemned to repeat it. Also, please excuse me (especially Julian Leviston) for maybe sounding too pessimistic and too offensive, the idea surely is exciting, my point is just that it excited me and probably many other persons before Bret Victor or Chris Granger did (very interesting) demos of it and what would _really_ excite me now is any glimpse of any idea whatsoever on how to make such things work in a general enough domain. Maybe they have or will have such idea, that would be cool, but until that time I think it's not unreasonable to restrain a bit, especially those ideas are relatively easy to realize in special domains and very hard to generalize to the wide scope of software people create. I would actually also love to hear from someone more knowledgeable about interesting historic attempts at doing such things, e.g. reversible computations, because there certainly were some: for one I remember a few years ago back in time debugging was quite a fashionable topic of talks (just google the phrase for a sampling), from a more hardware/physical standpoint there is http://en.wikipedia.org/wiki/Reversible_computing etc. Cheers, Jarosław Rzeszótko 2012/4/24 David Nolen dnolen.li...@gmail.com The best way to predict the future is to invent it On Tue, Apr 24, 2012 at 3:50 AM, Jarek Rzeszótko jrzeszo...@gmail.com wrote: You make it sound a bit like this was a working solution already, while it seems to be a prototype at best, they are collecting funding right now: http://www.kickstarter.com/projects/306316578/light-table. I would love to be proven wrong, but I think given the state of the project, many people overexcite over it: some of the things proposed aren't new, just wrapped into a nice modern design (you could try to create a new skin or UI toolkit for some Smalltalk IDE for a similiar effect), while for the ones that would be new like the real-time evaluation or visualisation there is too little detail to say whether they are onto something or not - I am sure many people thought of such things in the past, but it is highly questionable to what extent those are actually doable, especially in an existing language like Clojure or JavaScript. I am not convinced if dropping 200,000$ at the thing will help with coming up with a solution if there is no decent set of ideas to begin with. I would personally be much more enthusiastic if the people behind the project at least outlined possible approaches they might take, before trying to collect money. Currently it sounds like they just plan to hack it until it handles a reasonable number of special cases, but tools that work only some of the time are favoured by few. I think we need good theoretical approaches to problems like this before we can make any progress in how the actual real tools work like. Cheers, Jarosław Rzeszótko 2012/4/24 Julian Leviston jul...@leviston.net Thought this is worth a look as a next step after Brett Victor's work (http://vimeo.com/36579366) on UI for programmers... http://www.kickstarter.com/projects/ibdknox/light-table We're still not quite there yet IMHO, but that's getting towards the general direction... tie that in with a tile-script like language, and I think we might have something really useful. Julian ___ fonc mailing list fonc@vpri.org http://vpri.org/mailman/listinfo/fonc ___ fonc mailing list fonc@vpri.org http://vpri.org/mailman/listinfo/fonc ___ fonc mailing list fonc@vpri.org http://vpri.org/mailman/listinfo/fonc ___ fonc mailing list
Re: [fonc] LightTable UI
(Hi Toby) And don't forget that John McCarthy was one of the very first to try to automatically compute inverses of functions (this grew out of his PhD work at Princeton in the mid-50s ...) Cheers, Alan From: Toby Schachman t...@alum.mit.edu To: Fundamentals of New Computing fonc@vpri.org Sent: Tuesday, April 24, 2012 9:48 AM Subject: Re: [fonc] LightTable UI Benjamin Pierce et al did some work on bidirectional computation. The premise is to work with bidirectional transformations (which they call lenses) rather than (unidirectional) functions. They took a stab at identifying some primitives, and showing how they would work in some applications. Of course we can do all the composition tricks with lenses that we can do with functions :) http://www.seas.upenn.edu/~harmony/ See also Gerald Sussman's essay Building Robust Systems, http://groups.csail.mit.edu/mac/users/gjs/6.945/readings/robust-systems.pdf In particular, he has a section called Constraints Generalize Procedures. He gives an example of a system as a constraint solver (two-way information flow) contrasted with the system as a procedure (one-way flow). Also I submitted a paper for Onward 2012 which discusses this topic among other things, http://totem.cc/onward2012/onward.pdf My own interest is in programming interfaces for artists. I am interested in these causally agnostic programming ideas because I think they could support a more non-linear, improvisational approach to programming. Toby 2012/4/24 Jarek Rzeszótko jrzeszo...@gmail.com: On the other hand, Those who cannot remember the past are condemned to repeat it. Also, please excuse me (especially Julian Leviston) for maybe sounding too pessimistic and too offensive, the idea surely is exciting, my point is just that it excited me and probably many other persons before Bret Victor or Chris Granger did (very interesting) demos of it and what would _really_ excite me now is any glimpse of any idea whatsoever on how to make such things work in a general enough domain. Maybe they have or will have such idea, that would be cool, but until that time I think it's not unreasonable to restrain a bit, especially those ideas are relatively easy to realize in special domains and very hard to generalize to the wide scope of software people create. I would actually also love to hear from someone more knowledgeable about interesting historic attempts at doing such things, e.g. reversible computations, because there certainly were some: for one I remember a few years ago back in time debugging was quite a fashionable topic of talks (just google the phrase for a sampling), from a more hardware/physical standpoint there is http://en.wikipedia.org/wiki/Reversible_computing etc. Cheers, Jarosław Rzeszótko 2012/4/24 David Nolen dnolen.li...@gmail.com The best way to predict the future is to invent it On Tue, Apr 24, 2012 at 3:50 AM, Jarek Rzeszótko jrzeszo...@gmail.com wrote: You make it sound a bit like this was a working solution already, while it seems to be a prototype at best, they are collecting funding right now: http://www.kickstarter.com/projects/306316578/light-table. I would love to be proven wrong, but I think given the state of the project, many people overexcite over it: some of the things proposed aren't new, just wrapped into a nice modern design (you could try to create a new skin or UI toolkit for some Smalltalk IDE for a similiar effect), while for the ones that would be new like the real-time evaluation or visualisation there is too little detail to say whether they are onto something or not - I am sure many people thought of such things in the past, but it is highly questionable to what extent those are actually doable, especially in an existing language like Clojure or JavaScript. I am not convinced if dropping 200,000$ at the thing will help with coming up with a solution if there is no decent set of ideas to begin with. I would personally be much more enthusiastic if the people behind the project at least outlined possible approaches they might take, before trying to collect money. Currently it sounds like they just plan to hack it until it handles a reasonable number of special cases, but tools that work only some of the time are favoured by few. I think we need good theoretical approaches to problems like this before we can make any progress in how the actual real tools work like. Cheers, Jarosław Rzeszótko 2012/4/24 Julian Leviston jul...@leviston.net Thought this is worth a look as a next step after Brett Victor's work (http://vimeo.com/36579366) on UI for programmers... http://www.kickstarter.com/projects/ibdknox/light-table We're still not quite there yet IMHO, but that's getting towards the general direction... tie that in with a tile-script like language, and I think we might have something really useful. Julian
Re: [fonc] LightTable UI
Many thanks everyone, one more good resource I found is this paper by David Eppstein attempting to do automatic inversion of simple Lisp functions: http://www.ics.uci.edu/~eppstein/pubs/Epp-IJCAI-85.pdf Gives a good overview of other work as well and sheds some light on the difficulties involved in the problem. Cheers, Jarosław Rzeszótko W dniu 24 kwietnia 2012 18:48 użytkownik Toby Schachman t...@alum.mit.edunapisał: Benjamin Pierce et al did some work on bidirectional computation. The premise is to work with bidirectional transformations (which they call lenses) rather than (unidirectional) functions. They took a stab at identifying some primitives, and showing how they would work in some applications. Of course we can do all the composition tricks with lenses that we can do with functions :) http://www.seas.upenn.edu/~harmony/ See also Gerald Sussman's essay Building Robust Systems, http://groups.csail.mit.edu/mac/users/gjs/6.945/readings/robust-systems.pdf In particular, he has a section called Constraints Generalize Procedures. He gives an example of a system as a constraint solver (two-way information flow) contrasted with the system as a procedure (one-way flow). Also I submitted a paper for Onward 2012 which discusses this topic among other things, http://totem.cc/onward2012/onward.pdf My own interest is in programming interfaces for artists. I am interested in these causally agnostic programming ideas because I think they could support a more non-linear, improvisational approach to programming. Toby 2012/4/24 Jarek Rzeszótko jrzeszo...@gmail.com: On the other hand, Those who cannot remember the past are condemned to repeat it. Also, please excuse me (especially Julian Leviston) for maybe sounding too pessimistic and too offensive, the idea surely is exciting, my point is just that it excited me and probably many other persons before Bret Victor or Chris Granger did (very interesting) demos of it and what would _really_ excite me now is any glimpse of any idea whatsoever on how to make such things work in a general enough domain. Maybe they have or will have such idea, that would be cool, but until that time I think it's not unreasonable to restrain a bit, especially those ideas are relatively easy to realize in special domains and very hard to generalize to the wide scope of software people create. I would actually also love to hear from someone more knowledgeable about interesting historic attempts at doing such things, e.g. reversible computations, because there certainly were some: for one I remember a few years ago back in time debugging was quite a fashionable topic of talks (just google the phrase for a sampling), from a more hardware/physical standpoint there is http://en.wikipedia.org/wiki/Reversible_computingetc. Cheers, Jarosław Rzeszótko 2012/4/24 David Nolen dnolen.li...@gmail.com The best way to predict the future is to invent it On Tue, Apr 24, 2012 at 3:50 AM, Jarek Rzeszótko jrzeszo...@gmail.com wrote: You make it sound a bit like this was a working solution already, while it seems to be a prototype at best, they are collecting funding right now: http://www.kickstarter.com/projects/306316578/light-table. I would love to be proven wrong, but I think given the state of the project, many people overexcite over it: some of the things proposed aren't new, just wrapped into a nice modern design (you could try to create a new skin or UI toolkit for some Smalltalk IDE for a similiar effect), while for the ones that would be new like the real-time evaluation or visualisation there is too little detail to say whether they are onto something or not - I am sure many people thought of such things in the past, but it is highly questionable to what extent those are actually doable, especially in an existing language like Clojure or JavaScript. I am not convinced if dropping 200,000$ at the thing will help with coming up with a solution if there is no decent set of ideas to begin with. I would personally be much more enthusiastic if the people behind the project at least outlined possible approaches they might take, before trying to collect money. Currently it sounds like they just plan to hack it until it handles a reasonable number of special cases, but tools that work only some of the time are favoured by few. I think we need good theoretical approaches to problems like this before we can make any progress in how the actual real tools work like. Cheers, Jarosław Rzeszótko 2012/4/24 Julian Leviston jul...@leviston.net Thought this is worth a look as a next step after Brett Victor's work (http://vimeo.com/36579366) on UI for programmers... http://www.kickstarter.com/projects/ibdknox/light-table We're still not quite there yet IMHO, but that's getting towards the general direction... tie that in with a
Re: [fonc] LightTable UI
Some interesting stuff there, Toby Schachman. I agree that bidirectional computation and `causally agnostic` computation are both quite valuable. I've been playing with such models myself, i.e. stable stateless models for greater resilience and robustness and partitioning tolerance [2]. Unfortunately, it is not clear to me that they answer Jaroslaw Rzeszótko's concerns. Mr. Rzeszótko's own suggestion of reversible computation also seems orthogonal to the problem of abstracting time and temporal debugging. I would suggest looking into temporal computing models, i.e. such that our programs specify not only what happens but when they happen. This makes projecting the past and future of a model's state much more accessible. The difficulty is integrating these predictive models with open systems, concurrency, and side-effects. I've done some work to make observing the future of a model compositional, open, and scalable with reactive demand programming [1]. By `compositional` I mean that RDP doesn't actually perform the predictions, but does ensure they flow through the model, making it easy to separate the responsibilities of making the predictions and leveraging them. My interest was not so much for debugging, rather to provide temporal `slack` in a distributed system and eliminate need for stateful semantics in a broad class of problems (computing derivatives, detecting changes, etc.). Thus the temporal model is built deep into RDP rather than slapped on via an IDE. Regards, David Barbour [1] http://awelonblue.wordpress.com/2011/05/28/anticipation-in-rdp/ [2] http://awelonblue.wordpress.com/2012/03/14/stability-without-state/ On Tue, Apr 24, 2012 at 9:48 AM, Toby Schachman t...@alum.mit.edu wrote: Benjamin Pierce et al did some work on bidirectional computation. The premise is to work with bidirectional transformations (which they call lenses) rather than (unidirectional) functions. They took a stab at identifying some primitives, and showing how they would work in some applications. Of course we can do all the composition tricks with lenses that we can do with functions :) http://www.seas.upenn.edu/~harmony/ See also Gerald Sussman's essay Building Robust Systems, http://groups.csail.mit.edu/mac/users/gjs/6.945/readings/robust-systems.pdf In particular, he has a section called Constraints Generalize Procedures. He gives an example of a system as a constraint solver (two-way information flow) contrasted with the system as a procedure (one-way flow). Also I submitted a paper for Onward 2012 which discusses this topic among other things, http://totem.cc/onward2012/onward.pdf My own interest is in programming interfaces for artists. I am interested in these causally agnostic programming ideas because I think they could support a more non-linear, improvisational approach to programming. Toby 2012/4/24 Jarek Rzeszótko jrzeszo...@gmail.com: On the other hand, Those who cannot remember the past are condemned to repeat it. Also, please excuse me (especially Julian Leviston) for maybe sounding too pessimistic and too offensive, the idea surely is exciting, my point is just that it excited me and probably many other persons before Bret Victor or Chris Granger did (very interesting) demos of it and what would _really_ excite me now is any glimpse of any idea whatsoever on how to make such things work in a general enough domain. Maybe they have or will have such idea, that would be cool, but until that time I think it's not unreasonable to restrain a bit, especially those ideas are relatively easy to realize in special domains and very hard to generalize to the wide scope of software people create. I would actually also love to hear from someone more knowledgeable about interesting historic attempts at doing such things, e.g. reversible computations, because there certainly were some: for one I remember a few years ago back in time debugging was quite a fashionable topic of talks (just google the phrase for a sampling), from a more hardware/physical standpoint there is http://en.wikipedia.org/wiki/Reversible_computingetc. Cheers, Jarosław Rzeszótko 2012/4/24 David Nolen dnolen.li...@gmail.com The best way to predict the future is to invent it On Tue, Apr 24, 2012 at 3:50 AM, Jarek Rzeszótko jrzeszo...@gmail.com wrote: You make it sound a bit like this was a working solution already, while it seems to be a prototype at best, they are collecting funding right now: http://www.kickstarter.com/projects/306316578/light-table. I would love to be proven wrong, but I think given the state of the project, many people overexcite over it: some of the things proposed aren't new, just wrapped into a nice modern design (you could try to create a new skin or UI toolkit for some Smalltalk IDE for a similiar effect), while for the ones that would be new like the real-time evaluation or visualisation there is
Re: [fonc] LightTable UI
FYI: at last week's Scala Days there was a talk about Asymmetric Lenses in Scala; these are unidirectional. http://skillsmatter.com/podcast/scala/asymmetric-lenses-scala Op 24 apr. 2012, om 18:48 heeft Toby Schachman het volgende geschreven: Benjamin Pierce et al did some work on bidirectional computation. The premise is to work with bidirectional transformations (which they call lenses) rather than (unidirectional) functions. They took a stab at identifying some primitives, and showing how they would work in some applications. Of course we can do all the composition tricks with lenses that we can do with functions :) http://www.seas.upenn.edu/~harmony/ See also Gerald Sussman's essay Building Robust Systems, http://groups.csail.mit.edu/mac/users/gjs/6.945/readings/robust-systems.pdf In particular, he has a section called Constraints Generalize Procedures. He gives an example of a system as a constraint solver (two-way information flow) contrasted with the system as a procedure (one-way flow). Also I submitted a paper for Onward 2012 which discusses this topic among other things, http://totem.cc/onward2012/onward.pdf My own interest is in programming interfaces for artists. I am interested in these causally agnostic programming ideas because I think they could support a more non-linear, improvisational approach to programming. Toby 2012/4/24 Jarek Rzeszótko jrzeszo...@gmail.com: On the other hand, Those who cannot remember the past are condemned to repeat it. Also, please excuse me (especially Julian Leviston) for maybe sounding too pessimistic and too offensive, the idea surely is exciting, my point is just that it excited me and probably many other persons before Bret Victor or Chris Granger did (very interesting) demos of it and what would _really_ excite me now is any glimpse of any idea whatsoever on how to make such things work in a general enough domain. Maybe they have or will have such idea, that would be cool, but until that time I think it's not unreasonable to restrain a bit, especially those ideas are relatively easy to realize in special domains and very hard to generalize to the wide scope of software people create. I would actually also love to hear from someone more knowledgeable about interesting historic attempts at doing such things, e.g. reversible computations, because there certainly were some: for one I remember a few years ago back in time debugging was quite a fashionable topic of talks (just google the phrase for a sampling), from a more hardware/physical standpoint there is http://en.wikipedia.org/wiki/Reversible_computing etc. Cheers, Jarosław Rzeszótko 2012/4/24 David Nolen dnolen.li...@gmail.com The best way to predict the future is to invent it On Tue, Apr 24, 2012 at 3:50 AM, Jarek Rzeszótko jrzeszo...@gmail.com wrote: You make it sound a bit like this was a working solution already, while it seems to be a prototype at best, they are collecting funding right now: http://www.kickstarter.com/projects/306316578/light-table. I would love to be proven wrong, but I think given the state of the project, many people overexcite over it: some of the things proposed aren't new, just wrapped into a nice modern design (you could try to create a new skin or UI toolkit for some Smalltalk IDE for a similiar effect), while for the ones that would be new like the real-time evaluation or visualisation there is too little detail to say whether they are onto something or not - I am sure many people thought of such things in the past, but it is highly questionable to what extent those are actually doable, especially in an existing language like Clojure or JavaScript. I am not convinced if dropping 200,000$ at the thing will help with coming up with a solution if there is no decent set of ideas to begin with. I would personally be much more enthusiastic if the people behind the project at least outlined possible approaches they might take, before trying to collect money. Currently it sounds like they just plan to hack it until it handles a reasonable number of special cases, but tools that work only some of the time are favoured by few. I think we need good theoretical approaches to problems like this before we can make any progress in how the actual real tools work like. Cheers, Jarosław Rzeszótko 2012/4/24 Julian Leviston jul...@leviston.net Thought this is worth a look as a next step after Brett Victor's work (http://vimeo.com/36579366) on UI for programmers... http://www.kickstarter.com/projects/ibdknox/light-table We're still not quite there yet IMHO, but that's getting towards the general direction... tie that in with a tile-script like language, and I think we might have something really useful. Julian ___ fonc mailing list fonc@vpri.org http://vpri.org/mailman/listinfo/fonc
