> we have to know far more than just the basic consturcts [sic] of the language and things like IO

Did anyone else find these annoying? I recall building a great deal of abstraction into my systems 20 years ago, and we certainly used frameworks at various layers of the system. We had to know far more than basic language constructs and IO.

Today's systems and frameworks are more available (open-source) and differently targeted (e.g. cloud-scale problems), but they're still just building abstractions on what came before, just like us old fogies were doing 20 years ago. The problems and solutions are not qualitatively different -- they just have different scale and connectivity.

All that said, Light Table seems pretty cool. But it's not evidence of deeper insight than what came before.

It's interesting that the author, who is speaking about things that were happening 20 years ago, graduated from college in 2008 (http://www.chris-granger.com/resume/) and thus 20 years ago he was likely a very small child.

This combination of lack of depth and yet grandeur is seen in other projects and is annoying because it means that one is forced to wade through a lot of noise to understand projects like nodejs, couchdb, etc. And it does the people who write like that a disservice. Rather then overselling their weak knowledge they should point out the cool stuff in what they are doing and let that speak for itself. It's counterproductive to pretend to be smarter than you are.

I blame the whole Silicon Valley "10x hacker" mentality. There's a whole lot of young and frankly pretty mediocre developers strutting around thinking that because they (a) live in the valley and (b) built shittytodoapp.io they're at the same level as Knuth.

tsk tsk tsk

Even UML had support for PSM, PIM, etc.

http://www.youtube.com/watch?v=FvmTSpJU-Xc&feature=youtu...

Update I wasn't being terribly fair. Granger might simply not have been aware. In that case I hope he sees my comment and watches the above video. :)

Yes, get your history and citation right to avoid being flamed. But no, it didn't end with Smalltalk (or Lisp, or whatever) and we are not just going back to that.

That's the wrong motivation for understanding the history of computing as it relates to what you are working on. There are things to learn from history. It's not the ability to correctly cite Smalltalk etc. to quiet some older programmers , it's the ability to compare, contrast and learn from what came before. The really debilitating thing about not understanding the history is that you are doomed to repeat the same mistakes; it's better if you can make new mistakes.

For example, you say "But there really is something special in Light Table". Great. What is it?

Again, its a blog post and a talk, I don't think we should expect rigor on previous/related work coverage at this point, that will come with time.

It takes either hubris or ignorance to believe your ideas are completely original. Whether Chris is aware of it or not, Light Table is not a new idea. I'm not suggesting it isn't a good one because I believe it is. However the way he worded his post suggests to me that he is probably not aware of the giants upon whose shoulders he now stands.

Nobody just picked up a guitar and invented rock-and-roll. The theory or relativity didn't just come to Einstein one day. No good idea is born in a vacuum.

I only rain on the parade a little in the hopes that his writing will improve and to raise awareness in people who aren't aware that these are good ideas and that there have been many attempts to develop them.

There is a lot of innovations here, and yes, they are probably building on 20 years of related work THAT GO WAY BEYOND SMALLTALK. If he goes into a smalltalk credit, why not Lisp machines? Why not VPLs? Why not every little research project that has attempted this in the past (including my own work)? And he is still correct: the vast majority of programmers haven't been influenced by this at all, we failed, and he is trying again hopefully with something that will work! If he was writing a technical paper, then he could discuss everything in a related work section; but it was a strangeloop talk + blog post, what kind of rigor are you expecting?

His blog post made sweeping generalizations about what programming was like twenty years ago that are clearly inaccurate at their worst or at least misleading at best.

He doesn't need to cite anything. He could just make fewer generalizations of the sort in his post. Many programmers from twenty years ago were working on the very kinds of projects he is today. His might be better for many reasons than those early attempts but he does himself and his audience a disservice by not being aware of them.

20 years ago most programmers were not using Smalltalk or lisp machines or whatever, even if those things existed they weren't used often, so the author is technically correct about the "state of the art" with the caveat that their were many attempts to go beyond this but nothing got any traction.

Also, you are incorrect about 20 years ago. The first example of liveness and directness in programming was in...1962 with the Sutherland/Sketchpad demo. 50 years ago.

It's all really cool stuff. I'm really glad that Light Table is making it popular again. Maybe this time we can at least give a nod to where these ideas come from so that more people can be aware. New instead of novel.

Smalltalk had an interactive UX in 1986 or so when I used it first for some CAD stuff. Or is there a special definition of 'interactive UX' which would rule out what smalltalk offered back then?

The debugger already is omniscient in terms of what is going on within the program, but it's inept at showing it to you. It's too low-level in that it doesn't know what specific entities are important in your program. It knows addresses, variables, maybe objects. But you have a mental model and instead of trying to get your mental model into low level terms you can program it to have some notion of what to display.

In principle gdb could look at everything that's going on, but in practice doing so would (a) hit a bug in the compiler's debug output and fail, and (b) take forever for any program worth debugging.

Grr.

You can see the results here http://www.universalsubtitles.org/en/videos/9Ws8B7yC3Fjl/en/... and you can also help make the subtitles better.

--

So the first thing I thought we would do is create a little custom git widget that shows the files modified in our repository.

So we add a custom object.

And we're going to write some clojure script code just to hold the state of our (circle??) the git status

We just need a way then to get that

So we ask the server for it

And... here we're just creating some html representation of our list of files

And then when we save

We're going to make sure we update

So if we run this

We should see

Yes, there we go we have a list of modified files

We can add some css to make it look prettier

And now I can just move this wherever we want

I'll put it down here

And let's actually open a file and modify it and prove that our widget is actually working

So, we have server.clj here

And when I save it

Yes, there we go

It's changed

And if I remove that modification, then it goes away, great!

Then I thought we should do something a bit more interesting than that.

I've been working on a game with my little brother

So let's build an environment to play that game in and work on it

It's written in Javascript so we're going to need a canvas element

So that we can put the game on the canvas

Canvas by default isn't visible so you dont't see it immediately

So Let's give it a background, black just so we can actually see that we added something.

here we go

And we'll move this over to this this side so don't have it in the middle of our workspace

And that as well

Let's run the game to make sure this is all working as expected

There's the game

there is the javascript file

execute it

there we go

Now we have the game running, You can see I can play it here

You can move around, some little bad guy shooting me. Cool!

now I talked about being able to build, to bring your abstractions into the environment

Let's control the game from light table

I add another custom object

We're going to create start and stop buttons for the game

We start writing the clojure script here

we create a little function to create a button

That has a label and an action

And here is our init which just returns the html that we want it to to be represented as

And you can see after executing it you get a start and stop

Some css here , that's a little too big

Let's actually shrink the font size a bit

that's still too big.. 11 60

Great, now if I click stop, he stops moving there you go

And If I click start he starts moving again

And you can see what this init function is doing is calling our javascript code

Move this guy down here

So let's take this up a notch

Let's actually bring one of the abstractions from the game directly in.

So games are usually composed of entities that get drawn to the canvas

So let's create a list of all the entities

to do that

We need some state for our entities

And a way obviously to add and remove them

And then we need a representation of them in html

We have this little item function

We're setting our on-add and on-remove functions within our game to our add and remove

Execute this and

Do the magic of some data binding here

We'll see that

Every time something gets shot a new entity is added to the canvas

So if I shoot this guy, he actually explodes into a bunch of shrapnel

let me show this

there you go

so there is a bunch of shrapnel that's been added

And as it sort of fades away it goes away again

Cool!

So we've actually created a little environment for our game here

the whole thing was less than about 50 lines of code

And it was completely trivial to build

there you go!

Fun little way to show how

You can extend light table

That's such a big chunk of the market that they're missing out on.

Can't you be grateful that the author shared something of value

Why should someone be grateful for content they cannot consume?

Should they give up on sharing it, because they do not have the time to invest in making it better?

He never said they shouldn't share it at all, he only said he wished they would add subtitles. Nowhere did he say "if they don't add subtitles, you know what, fuck it, they shouldn't share the video at all".

According to the Journal of Deaf Studies and Deaf Education, an article published in 2005 cites 11MM HOH and deaf individuals in the United States[1]. The Population Reference Bureau cites 296MM US citizens in the same year[2]. It's important to note that according to the first source, "over half" of those that are HOH or deaf are over 65 - likely not the target market of this video.

Even if we were to completely ignore the demographic issue of who makes up the majority of HOH and deaf individuals, we're talking about just over 3.7% of the population in the US (I would assume it's roughly similar when extrapolated to the entire internet population).

I think that anyone for whom the HOH and deaf population was a target market would certain take every opportunity to make their materials accessible.

[1] http://jdsde.oxfordjournals.org/content/11/1/112.full - ABSTRACT [2] http://www.prb.org/pdf05/05worlddatasheet_eng.pdf - PAGE 2

I'm feeling increasingly like an old gaffer complaining about these "young 'uns" and their "yoo tubes" (at a middling 30-something), but I see this trend toward video when text would suffice as evidence of a societal lack of good (writing) education.

Sure, in the OP's instance, it's a presentation he made to someone else, so a video is probably easiest, but this was a good opportunity to rant.

EDIT: And now the reply link appears. Weird.

Think it's because there's so much written information now, I can't even read 1% of the stuff I want to. After reading "all day", good videos, e.g. talks, are refreshing.

Am I the one missing out? Probably, but I also pass a lot of content that I do like around to lots of people, so the authors also lose out on a potential fanbase/readership/whatever.

I've made webcast videos before. It's not easy. I also didn't caption them because it's a hell of a lot of work. Sorry. You can ask, but you can't expect.

Hehe, too late. Sorry ;)

Enjoy!

And I agree that there should be more consideration for people that are hard of hearing or deaf. Slides are a lot easer in this respect.

[edit: Just saw somebody else linking to this same site. Sorry.]

What he calls abstractions are nothing of the sort.

I've found this post quite useful: http://opinionator.blogs.nytimes.com/2012/07/23/zombie-nouns...

Anyone care to enlighten me?

I believe this will help immensely when approached from the right side, e.g. projects split into separate components with each having its own IDE setup (world, if you may) developed from the ground up together with the component itself.

The dissonance between Bret's visions and where even a quite progressive modern IDE is at disturbed me deeply. Nothing that Chris showed was "trivial" when seen from the perspective of how things might be rather than how Eclipse does things.

Something like that could make writing web applications much easier than it is right now. Interactive web application development could be a real game changer.