Chris Granger

Speaking as a Lisper, I have to admit that this is an open question for me. On the one hand, the needs of parallel systems and state management offered by functional languages stands to bring Lisps (Clojure, Common Lisp etc) and other languages like Erlang ever more attention as we programmers attempt to manage the complexities of multicore design and distributed systems. As a systems programming language I think that lisp has utterly failed. The Lisp machines are dead for various reasons (which I'm researching right now as a side-project) and to the best of my knowledge compiled lisp has clearly not taken the place of C in building operating systems (although I hope to do exactly that as does the author of [http://www.loper-os.org/]). All of this comes down to an individual's definition of utility. Lisp is by definition of Turing Completeness just as capable as any other language you may wish to name, but with the usual Turing Tarpit or small language warning that you may have to roll your own. My perception, and one which several posts here on HN has affirmed is that traditionally Lisp was used by lone AI researchers who needed the power to roll their own anything quickly and efficiently. As a result of this "roll my own" mentality and simple lack of the internet (it was early and mid 1980s or so) libraries and SDKs as we know them were never built for Lisp systems. Another difficulty is that as several other comments note there is no "one true" standard for Lisp. There…

The first thing I though looking at the #3 is: Who is http://chris-granger.com ? Answer: He was the main developer of the Eve programing language.

@ibdknox 's blog "Two years of Eve" is useful to understand why of Eve: http://www.chris-granger.com/

It's worth mentioning that Chris Granger wrote an excellent blog post[0] that's similar to this one, but far more succinct. While I don't use Light Table, I'm still a huge fan regardless. >What would programming be to you in an ideal world? More visual, especially when observing execution. When you're debugging anything non-synchronous—be it events, messaging, distributed systems—it usually sucks, even in the rare case that you do have good tooling. I'd like to create, view and debug my code in an almost entirely visual fashion. I want to see events and messages perfuse through the structure of what I'm building, with complete temporal control of the view. [0] http://www.chris-granger.com/2014/03/27/toward-a-better-programming/

"Even with a principled approach, I think I managed to build a system that only I can really get around in." Interesting. Power vs difficulty in debugging. " BOT filled its goals of an architecture that is infinitely extensible and runtime modifiable, but that degree of power came at a cost - despite its simplicity the resulting program is very hard to follow. I've recently come to understand that this is because mixins are fundamentally an anti-pattern and BOT is basically dynamic mixins." BOT is described here: http://www.chris-granger.com/2013/01/24/the-ide-as-data/

> I mean, the legislation.gov.uk website is great too – they designed it after a brilliant research on user needs. The only thing which remains bad is the very final product: the law. Lawyers made it. Why couldn’t law be designed by designers as well? Why couldn't your app's core business logic rules be designed by designers as well? See: http://www.chris-granger.com/2015/01/26/coding-is-not-the-new-literacy…

I was sold on the game video, then the article talks about SICP and LISP - nice! Sounds like great fun and possibly some real innovation here. I hope it's beta for a few years like Minecraft with a strong developer community around it. Reminds me of the lofty goals of http://lighttable.com and EVE http://www.chris-granger.com/2014/10/01/beyond-light-table/

I found LightTable* as a great way to grok functional programming - you can actually see how data moves around. Really brilliant. *Lighttable IDE: http://www.chris-granger.com/lighttable/

This was an excellent talk at the Conj, and the talk was the best explanations of entity systems I've yet found. I also recommend his Anatomy of a Knockout which also covers more of this topic: http://www.chris-granger.com/2012/12/11/anatomy-of-a-knockout/ with discussion: http://news.ycombinator.com/item?id=4907791

For games, Chris Granger and his team have coded up a prototype game in Clojurescript using the Entity-Component-System architecture, which seems to be a good fit for functional languages. It might be worth checking out: http://www.chris-granger.com/2012/12/11/anatomy-of-a-knockout/

> How do you do this with a text driven program? If you haven't watched https://vimeo.com/36579366 , I highly recommend it. Chris Granger, after watching this, created http://www.chris-granger.com/2012/02/26/connecting-to-your-creation/ which you can download, and applies to ClojureScript, which is (tada!) text based. Also, I had a chance to use time traveling virtual machine (which works independently of how your code was produced) in 2007, and while I haven't had a chance to use them, I know that source-aware time traveling debuggers have made huge strides recently. > So you claim there is no benefit to be had. I claim the existing solutions are already failing. These claims are not contradictory. I agree that existing solutions are failing in various ways, but I still disagree that the "code as rich data" would provide benefit. > If one solution gets enough of these things right, there is no reason why it wouldn't succeed just because text-driven. (But it is also possible to do it correctly with text) So, if possible to do correctly when text driven, why is text driven a problem? > If the program code is always to be consistent, it cannot be text, because text allows you to input invalid programs. So how is text not a leaky abstraction? All programming abstractions are leaky in one way or another, and text is no different. In my opinion, the leak that it is possible, during design time, to have an invalid program (which will be rejected as such prior to execution)…

From the Eve announcement [1]: > Eve is our way of bringing the power of computation to everyone, not by making everyone a programmer but by finding a better way for us to interact with computers. The more I try to teach programming to non-programmers, the less I understand the notion of what "programming for non-programmers" really means...in the same way that "writing, but for people who can't write" is a bizarre concept. Programming, and the notion that code is an explicit way to communicate with a computer, isn't just an inconvenient technical detail that prevents amateurs from reaching their full computational power...it is a true way of thinking, and to not be able to do it limits you in the same way that being illiterate prevents you from creating the next American Great Novel. I've always believed that understanding a for-loop and if-statement are all you need to really wield the benefits of computation...but I've found that I constantly underestimate what an epiphany is to actually grok those concepts. It's not just the ability to abstract a routine, but the concept of a block of stored instructions and variables that is, as far as I can tell, pretty much alien to anyone who is not a programmer. Or a mathematician. I'm not saying that efforts like Eve should stop, or that they can't be significantly helpful in bringing greater understanding to non-programmers...I'm just saying its stated goal is incoherent and inherently unattainable, like trying to build a…

> It never said it was the "the uber clojure IDE", not even used any words to this effect. In the beginning it was clearly marketed as a clojure ide, and if you look at the comments on HN at the time it's clear that it was perceived as such. http://www.chris-granger.com/2012/04/12/light-table---a-new-ide-concep… https://news.ycombinator.com/item?id=3836978 >"Catering too much to other languages"? What does that even mean? Did anybody signed to the parent that it would only be for his favorite language (the "uber clojure IDE" he dreamt?)? It was due to huge community demand that LT promised to support Javascript and Python too. This is what broke it's back though. By trying to go with all languages at once they failed to focus on getting one right first. They should have added new ones later on. >Nobody stopped the parent or anyone else from using something existing "that actually works" or creating something even better. I've heard it many times over the years in the clojure world, "I'd start on an editor, but it looks like LT is going to be exactly what I want so I'll just wait." Only after its failure was apparent things like Gorilla-Repl popped up. > including having concretely inspired the Swift playground features (as the Swift designer admitted). I'd like a source for that. LT is directly inspired by the work of Bred Victor who _worked for apple_ and Swift has at least one of the Factor devs, which is a highly dynamic language with a live coding…

Could someone please explain to me why these tools are not commercially available? This is the desktop version of the app Bret Victor created: http://vimeo.com/64895205 The tools would make my live so much easier, I can not start to express how much science needs this. Why did no startup jump on implementing them, like "Light Table" [1]? Alternatively, why did Victor not release it commercially? He would not get rich, but I guess he does not need to earn money anymore. His tools could benefit humanity, from cancer research to safer cars. I really wonder, what the reason is why Mr. Victor never published any of his tools. It makes me sad to see such genius applications and all I can do is look at them. [1] http://www.chris-granger.com/2012/04/12/light-table---a-new-ide-concep… EDIT: Thank you @williamcotton for watching the summary (I didn't) Mr. Victor mentioned he will make it available on github, his account is: https://github.com/worrydream This is great news.

This is very true: "Leiningen and Cake, joined forces to become an all-powerful build tool. Then Leiningen reached version 2. (And let me tell you, Leiningen 2 alone makes Clojure worth using.)" Other build tools, and package managers, such as "bundler" in the Ruby world, seem pretty weak compared to Leiningen. This is a very powerful tool. The tooling and the eco-system are reaching a very powerful level. For now, I use Emacs as my editor, but I am waiting for LightTable ( http://www.chris-granger.com/2012/11/05/meet-the-new-light-table/ ) to get just a little further, and then I intend to switch to it. This whole article is good, but this is the part that gets to the heart of the matter: "Rubyists know that their language effectively got rid of for loops. In the same way, Clojure gets rid of imperative iteration in favor of declaration. Your thoughts shift away from place-oriented constructs like memory and gravitate to data structures and functions like map, reduce and filter. Your “class hierarchy” turns out to be a type system that happens to also lock away well-meaning functions into dark dungeons (more on that in another article), and getting away from that is freeing." That might be the best summary of the strengths of Clojure: it helps you think about data structures and transformation, rather than thinking about the ceremonial and imperative code that your language needs to hear.

This remembers me of Chris Granger's post "Coding is not the new literacy" [1]. Instead he argues "Modeling is the new literacy" and "In order to represent a system, we have to understand what it is exactly, but our understanding is mired in assumptions.". Modelling is still required in Star Trek. The computer can make many assumptions, but the user still has to adjust wrong assumptions using voice commands or panel commands, as shown in many episodes. [1] https://chris-granger.com/2015/01/26/coding-is-not-the-new-literacy/

maybe shifting the jobs' target.. to higher a level (finally!) ? Reminds me of: https://chris-granger.com/2015/01/26/coding-is-not-the-new-literacy/ modelling has been , is , and will be the needed literacy..

More prior art: the Light Table IDE https://chris-granger.com/2012/04/12/light-table-a-new-ide-concept/ (I haven't used it.)

Reminds me of Light Table https://chris-granger.com/2012/04/12/light-table-a-new-ide-concept/

Huh, not sure why the original link changed. It's still on my blog here: https://chris-granger.com/2012/04/12/light-table-a-new-ide-concept/

I think the closest we got to a closure of Light Table is this: https://chris-granger.com/2014/10/01/beyond-light-table/ Which includes: > Light Table will continue to go on strong. We haven’t talked too much about it lately, but it’s used by tens of thousands of people and still growing. We use it every day to help us build Eve and thanks to the awesome people in the community that has sprung up around it, it gets better every week. Judging by GitHub contribution data (https://github.com/LightTable/LightTable/graphs/contributors?from=2019… it seems there has only been 25 commits (from one author) since Sep 20, 2019.

I also remember a post on HN about Chris Granger's Lightable IDE? http://lighttable.com/ https://www.chris-granger.com/lighttable/ Although as ground breaking, it does not seemt to have 'taken off' as much as it should?

URL should probably be http://www.chris-granger.com/2016/07/21/two-years-of-eve/ also (2016)

That's a good suggestion. I'll do a little makeshift one here :) Blog posts are mostly here: http://incidentalcomplexity.com and a couple here: http://www.chris-granger.com Talks: https://www.youtube.com/watch?v=2_4ecWDohnk https://www.youtube.com/watch?v=5V1ynVyud4M https://www.youtube.com/watch?v=DShccXxyiAY https://www.youtube.com/watch?v=VZQoAKJPbh8 https://www.youtube.com/watch?v=a_o-ZzgpiK8 Prototypes are collected here: https://github.com/witheve/eve-experiments I'll try to make this nicer and put it on our homepage.

All 15 of them? The market has spoken, programmers want free stuff, and they’re happy doing it the old fashioned way. Except for those who aren’t content: [Insert videos from Bret Victor here] https://vimeo.com/36579366 Lighttable is another attempt that comes to mind: http://www.chris-granger.com/lighttable/

Its less the direction changing than the plan for how to get there. The major pieces to the roadmap is now: 1. Eve: Programming designed for humans (current) 2. Eve: Computation for all 3. Eve: The world scale computer http://www.chris-granger.com/2016/07/21/two-years-of-eve/ has some information on why. Selected quotes: "We learned with Light Table that we can't just slap a UI onto Javascript and expect it to work; the platform has to allow for the representation." "Another reason the platform is necessary is really counterintuitive: we need developers to like it before end users will. Technology diffuses from technical people to non-technical people over time."

"Of course ..." is that really true though? From the very beginning, the very first demo, Chris Granger mentions that he got inspired by Bret Victor's Inventing on Principle demo. He mentions it in the first blog post as well :p No mentions of smalltalk Chris Granger's first video on LightTable: https://www.youtube.com/watch?v=7XUWpze_A_s Chris Granger's first blog post on LightTable: http://www.chris-granger.com/2012/04/12/light-table-a-new-ide-concept/

More about Eve project: http://www.chris-granger.com/2014/10/01/beyond-light-table/

Most modern engines, as far as I know, implement a component-driven approach. You can see it in pretty much any kind of public engine like UE or Unity and it works really well. Composition over inheritance any day. I don't really see why you claim that it seems to be vaporware, considering it's one of the most implemented types of game engines currently. It is true that there are some degrees of limitations and implementations that different game engines go through and none of them is a 100% pure CES engine (something like http://www.chris-granger.com/2012/12/11/anatomy-of-a-knockout/ ), where all systems are separated from the components and the entities containing them. Usually you'd have sets of components and systems and whatnot and different hierarchies, but the gist of it is still a Component-driven system.

I didn't even realize Eve has a public release (as of a few months ago). https://github.com/witheve/Eve And there's a blog post describing the features of version 0. http://www.chris-granger.com/2015/08/17/version-0/