HN Theater @HNTheaterMonth

You are correct, Forth is not a institutional tool, more of a individual choice. IMO, one that allows you to prototype and debug interactively as you write your code and has been like that since the beginning.

It allows you to train yourself to have a complete control and command of your code making for tighter, simpler solutions for complex problems ( In my personal experience and comments for those that have been introduced to FORTH.)

If you consider that Embedded is a highly constrained resourced environment, then FORTH is a fantastic choice. Now step back, consider that statement once more, and you could be onto something even greater, as there is lots of resource waste-gates on modern OS and Computers. Now that Power is becoming a greater constrain resource, there might be an opportunity for someone to build something great in forth.

BTW the biggest back en used case is the bitcoint smart contract which is based on FORTH.

As you can see, and in full agreement in your statement, FORTH is a not a job magnet, IMO, you get better at programing understanding FORTH.

See Bret Victors talk, https://youtu.be/PUv66718DII you most of that already @ Forth ...! :;

Try it, you'll never go back! :)

⬐ anta40

>> IMO, you get better at programing understanding FORTH

Isn't assembly fit the place better?

:)

⬐ Gordonjcp

> IMO, you get better at programing understanding FORTH.

Modern cars don't have a magneto or carburettor, but you'll have a far better ability to fix your Jag if you also know how to fix your lawnmower.

⬐ spaintech

In the car analogy, it's more like learning and understanding the limitations of the Otto Engine so that you can build a better one... IMO. :) BTW, in aviation, where reliability, constancy, and longevity, they still use magnetos and carbs... :D :;

Not writing, but I have found all of Brett Victor's speeches to be incredibly inspiring on how I think about what I want to work on and where we're going.

Inventing on Principle by Brett Victor: https://www.youtube.com/watch?v=PUv66718DII

Growing a Language by Guy Steele: https://www.youtube.com/watch?v=lw6TaiXzHAE

We Really Don't Know How to Compute! by Gerald Sussman: https://www.youtube.com/watch?v=HB5TrK7A4pI

⬐ solarmist

This is great. This is one of the things that got me into programming, but as I’ve advanced the distance between idea and manifestation has gotten larger.

I can deal with it but I know for a fact many of the things I’ve done are poorer for it because playing and experimenting is so expensive.

⬐ O__________O

Obviously the linked YouTube has an impressive thesis, presentation, and handful of demos; at the very least inspired Figma’s design principles per one of the cofounders, which within 10 years went from an idea based on shifts in technology to a 20 billion dollar acquisition by Adobe.

That said, do feel like it’s missing more guidance on actual expectations, how-to guides, etc. Even forcing someone to watch a video is a huge ask; obviously still worth it, but to me points to the paradox it presents itself.

I found it it was Bred Victor 2012 talk = https://www.youtube.com/watch?v=PUv66718DII Laszlo Pandy 205 - implementation in Elm - Reactor

In my opinion the greatest example is Bret Victor's keynotes: https://www.youtube.com/watch?v=PUv66718DII https://www.youtube.com/watch?v=8pTEmbeENF4

Key points: * Simple to get it (without external knowledge) * Demos * Content sections and small focus time

Bret Victor's Inventing on Principle is even better (albeit it isn't only a product pitch): https://youtu.be/PUv66718DII

This video [0] is from February 2012, but as far as I know this tool is not yet implemented (or at least it is not widely used).

Basically as you are writing a function, you can write sample input for it, and it tells you the intermediate value of each variable inside this function, which lets you reason about the code, makes it trivial to know you've done something wrong, and would make developing a much more interactive experience overall.

In my experience, this is done by hand when writing a function, but a tool like this would make it automatic.

[0] https://www.youtube.com/watch?v=PUv66718DII

⬐ ricklamers

This gets pretty close for web applications: https://www.replay.io/

Another relevant talk: https://www.youtube.com/watch?v=Ml6Dp3F4Inc

Wow! What a fun thing to see this in the front page.

It's certainly not production ready, just a little side project I made for myself- definitely inspired by Manim (3blue1brown) and by Inventing on Principle by Bret Victor https://m.youtube.com/watch?v=PUv66718DII

I'm implementing Bret Victor's Inventing on Principle[1] in JS with Pixi.js and Vite (might switch to SvelteKit). Immutable data structures with Immer.

Right now, I have ported two Pixi.js examples so they update instantly without losing state. I'm also using Immer so I can add a slider for history (and future trails) without much more effort.

[1]: https://youtu.be/PUv66718DII?t=760

Inventing on principle: https://www.youtube.com/watch?v=PUv66718DII Thank you Bret Victor

> It's not deliberately designed to keep people out

Surely you must realize that you're protesting this because it has this reputation, though?

And surely you must realize that it has this reputation for a reason?

When I was a teenager and took my first calculus course, I struggled with summation for three days. When I finally went to my dad he looked at me funny and said "your teacher is an idiot, isn't he? It's a for loop."

I had been writing for loops for seven years at that age. I almost cried. It was like a lightswitch.

The problem was always that nobody had ever actually explained what the symbol meant in any practical way. Every piece of terminology was explained with other terminology, when there was absolutely no reason to do so.

Mathematics has the reputation for impermeability and unwelcomingness for a reason.

It's because you guys are ignoring us saying "we want to learn, please write out a cheat sheet" and saying "yes, but don't you see" instead of just building the easy on-ramp that every other field on earth has built

.

> > You might be tired of wandering into someone else's area of expertise and telling them: > > You must change! You must make it more accessible!

No, we generally just fix the problem. If people are saying "this isn't accessible enough," we just work on it.

I would like for you personally to be aware of Bret Victor's work. He's incredibly potent and clear on these topics.

Programmers work really really hard on learnability and understandability. This is a big deal to us. That's why we can't understand why it's not a big deal to you.

http://worrydream.com/LearnableProgramming/

We have, in fact, mostly given up on waiting for you, and started to make our own tooling to understand your work, using obvious principles like live editors and witnessable effects.

http://worrydream.com/MediaForThinkingTheUnthinkable/

Edit: those are the talk notes. Wrong link, sorry. I should have used this instead: https://vimeo.com/67076984

This is a big part of how we criticize ourselves, is for failing to provide the tooling to allow new modes of approach.

https://www.youtube.com/watch?v=PUv66718DII

We frequently think of our programming languages as new modes for thought. This line of discussion is particularly popular in the Lisp, Haskell, and Forth communities, though it crops up at some level everywhere.

We frequently think that the more opaque the language, the less useful it is in this way.

That's why programming languages, which are arguably 70 years old as a field, have so much more powerful tools for teaching and explanation than math, which is literally older than spoken language

You guys don't even have documentation extraction going yet. We have documentation where you have a little code box and you can type things and try it. You can screw with it. You can see what happens.

This is why we care about things like Active Reading and explorable explanations.

http://worrydream.com/ExplorableExplanations/

This is why we care about things like live reactive documents. It really changes your ability to intuitively understand things.

http://worrydream.com/Tangle/

Math hasn't grokked non-symbolic communication since Archimedes, that's why it took nearly two thousand years to catch up with him.

We are asking you to come into step with the didactic tools of the modern world. It's not the 1850s anymore. We have better stuff than blackboards.

Are these flat symbolic equations cutting it for you guys to communicate with one another? Sure.

Are they cutting it for you guys to onboard new talent, or make your wealth available to the outside? No. (Do you realize that there is an outside to you, which isn't true of most technical fields anymore?)

These problems are not unique to mathematics, of course. Formal logic is similar. Within my own field of programming, the AI field is similar, as is control theory, as tends to be database work. They don't want to open the doors. You have to spend six years earning it.

But the hard truth is there are more difficult fields than mathematics that have managed to surmount these problems, such as physics (which no, is not applied mathematics,) and I think it might be time to stop protesting and start asking yourself "am I failing the next generation of mathematicians?"

An example of who I believe to be genuinely good math communicators in the modern era are Three Blue One Brown.

.

> > Believe me, mathematicians are tired of non-mathematicians wandering up and saying: > > Look! Computer programs are easy and intuitive and everyone can understand them, even without training! Make math like that!

Then fix the problem.

It IS fixable.

.

> Do you really believe that math notation is deliberately designed to make it hard for people untrained in math to learn how to use it?

Given the way you guys push back on being asked to write simple reference material?

No, but I understand why they do.

.

> Do you really believe that no one has tried to make it more accessible?

No. Instead, I believe that nobody has succeeded.

Try to calm down a bit, won't you? People tried to explain Berkeley sockets in a simple way for 12 years before Beej showed up and succeeded. The Little Schemer was 16 years after Lisp.

Explaining is one of the very hardest things that exists.

We're not saying you didn't try! The battlefield is littered with the corpses of attempts to get past Flatland.

We're just saying "you haven't succeeded yet and this is important. Keep trying."

.

> Do you really believe you know more about why math notation is what it is than mathematicians and trained mathematics educators do?

No. The literal ask is for you to repair that. Crimeny.

⬐ Jensson

> Surely you must realize that you're protesting this because it has this reputation, though?

I've never heard anyone make this accusation until I read it here on HN today. The reputation doesn't seem to be widespread.

> Programmers work really really hard on learnability and understandability. This is a big deal to us. That's why we can't understand why it's not a big deal to you.

How to better teach math is like one of the most studied topics in education since it is so extremely important for so many outcomes. People learn programming faster since programming is simply easier, not because more effort has been done to make programming easy. There hasn't, way more effort has been put into making math easy and the math we have is the results of all that work.

https://en.wikipedia.org/wiki/List_of_mathematics_education_...

> Given the way you guys push back on being asked to write simple reference material?

Nobody pushes back on writing simple reference manuals. There are tons of simple reference manuals for math everywhere on the internet, in most math papers, in most math books, everywhere! Yet still people fail to understand it. Many billions has been put trying to improve math education, trying to find shortcuts, trying to do anything at all. You are simply ignorant thinking that there are some quick fix super easy to implement things that would magically make people understand math. There isn't. It is possible that math education could get improved, but it wont be a simple thing.

⬐ JohnHaugeland

> > Surely you must realize that you're protesting this because it has this reputation, though? > > I've never heard anyone make this accusation until I read it here on HN today. The reputation doesn't seem to be widespread.

blinks really?

It's kind of a famous thing. Teachers are taught how to cope with math phobia; other subjects (with the exception of dissection) generally do not create this effect.

.

> How to better teach math is like one of the most studied topics in education since it is so extremely

Unsuccessful

Many other disciplines are equally important and don't have the desperation for repair that math does

It's so bad that it's gotten into popular music a dozen times; you can easily point to Tom Lehrer, Weird Al, even 2 Chainz for broaching the topic

.

> People learn programming faster since programming is simply easier

Keep telling yourself that

Remember who's cracking things like four coloring.

.

> There hasn't, way more effort has been put into making math easy and the math we have is the results of all that work.

You seem not to be results focused.

.

> Nobody pushes back on writing simple reference manuals.

The person I was responding to was. Three different people have with me in this thread alone.

Notice that you've changed the topic to "reference manuals," which 𝗶𝘀 𝗻𝗼𝘁 𝘄𝗵𝗮𝘁 𝘄𝗮𝘀 𝗯𝗲𝗶𝗻𝗴 𝗿𝗲𝗾𝘂𝗲𝘀𝘁𝗲𝗱

Ostensibly this is the part at which you launch into an explanation about how a simple cheat sheet that says things like " || usually means absolute value or magnitude" somehow isn't possible, even though it totally is

Next you'll explain how simple summary symbols like that are somehow harder than Haskell, which was able to produce a cheat sheet just fine

In reality, mathematicians just don't have the faintest clue how difficult other fields are, and are too busy patting themselves on the backs for their challenging intellects to realize that their work is under-used due to their inability to produce legends and keys

.

> Yet still people fail to understand it.

You're not producing what's being requested, then you're surprised that what you're actually producing isn't working.

.

> trying to find shortcuts, trying to do anything at all.

All that's being requested is a two page operator cheat sheet. If you'd stop wisely pontificating and just try it, you'd find it's really quite straightforward.

I produced one for my students. It's just that my own education in mathematics only goes so far.

𝗜𝘁 𝗴𝗲𝗻𝘂𝗶𝗻𝗲𝗹𝘆 𝗶𝘀 𝗻𝗼𝘁 𝗱𝗶𝗳𝗳𝗶𝗰𝘂𝗹𝘁

You are doing the refusing you insist nobody's doing, right now

.

> You are simply ignorant thinking that there are some quick fix super easy to implement things

Not really, no.

I've succeeded at this.

You are protesting against things that were not requested. Nobody asked for any "quick fixes." Nobody asked for any "magical make understand."

These are things you said, not things I said.

I said something very simple and very practical. Something that very much can be done.

I want a two page PDF which puts operators next to their names, so the load on my memory is lower.

Every time I ask that, some math fan goes on forever about how things I never asked for aren't possible, and ties that up with personal attacks.

𝗧𝗵𝗶𝘀 𝗶𝘀 𝘄𝗵𝘆 𝗺𝗮𝘁𝗵 𝗵𝗮𝘀 𝗶𝘁𝘀 𝗿𝗲𝗽𝘂𝘁𝗮𝘁𝗶𝗼𝗻. 𝗬𝗼𝘂 𝗴𝘂𝘆𝘀 𝗰𝗮𝗻'𝘁 𝗮𝗻𝘀𝘄𝗲𝗿 𝘀𝗶𝗺𝗽𝗹𝗲 𝗾𝘂𝗲𝘀𝘁𝗶𝗼𝗻𝘀, 𝗮𝗻𝗱 𝘁𝗵𝗶𝗻𝗸 𝘁𝗵𝗲 𝗽𝗿𝗼𝗯𝗹𝗲𝗺 𝗶𝘀 𝘀𝗼𝗺𝗲𝘁𝗵𝗶𝗻𝗴 𝗼𝘁𝗵𝗲𝗿 𝘁𝗵𝗮𝗻 𝘆𝗼𝘂𝗿 𝗶𝗻𝗮𝗯𝗶𝗹𝗶𝘁𝘆 𝘁𝗼 𝘀𝗽𝗲𝗮𝗸 𝗽𝗹𝗮𝗶𝗻𝗹𝘆 𝗼𝗿 𝗽𝗿𝗼𝗱𝘂𝗰𝗲 𝗮𝗱𝗲𝗾𝘂𝗮𝘁𝗲 𝘀𝘁𝗿𝗮𝗶𝗴𝗵𝘁𝗳𝗼𝗿𝘄𝗮𝗿𝗱 𝗱𝗼𝗰𝘂𝗺𝗲𝗻𝘁𝗮𝘁𝗶𝗼𝗻.

Please keep the insults to yourself. Thanks.

.

> It is possible that math education could get improved

Please stop trying to solve every problem. Nobody asked you to take on that Herculean task. What was actually requested was a simple two page PDF. That's a thing that a single person can do in an hour (well, maybe as a webpage, making an actual PDF is a hassle.)

The constant attempt to change the topic to some greater thing blinds you to how easy fixing this actually is.

The statisticians can do it: http://web.mit.edu/~csvoss/Public/usabo/stats_handout.pdf

This isn't far off: https://en.wikipedia.org/wiki/Glossary_of_mathematical_symbo...

Seriously, nobody is saying "solve math education for all people."

For `|x|` it would just say "absolute value, magnitude, length, or cardinality."

It's a quick reference chart for people who already know the material but haven't actively used it for ten years, and to help know what to google for the rare cases where you don't. It doesn't teach anything.

This shouldn't be a big deal, and people keep asking for it because it would *really* help

⬐ klibertp

> What was actually requested was a simple two page PDF.

But this is impossible, because, as I learned today, "math is a small field without money for things like this".

Thanks to my discussion here I was able to shift my perspective. Instead of thinking about an abstract thing, like "improving readability of math papers to non-mathematicians", I understood that I have to focus on people! In other words, on a bunch of guys frustrated that other STEM guys earn multiples of what they earn, even though their fields are so much "easier". Why would they help those various others use their work? They worked so hard to create the papers, living in a (shared with a philosopher) one bedroom apartment, writing their revolutionary insights on tissues stolen from McDonalds with a piece of charcoal - while those others can afford to buy computers (and even paper) easily, even though they don't work as hard as mathematicians at all!

It's just so unfair, and of course it's not like mathematicians are jealous or anything (not at all! really! honest!), it's just genuinely so much "harder" to do math, that most of those others won't be able to understand no matter what! Even if they actually listened to the masses and did as requested, the mathematicians already know that it would be useless, so there's no point in trying. Also, this is obvious, but worth noting: saying that most people are simply too dumb to ever understand the intricacies of math is not a prejudiced bias, ok, that's simply a conclusion of centuries of research into math education!

I honestly stopped expecting they'll do anything sensible ever, unless they really have no other choice. You might win against some people, but you won't ever defeat human nature.

⬐ JohnHaugeland

Imagine saying that it's impossible to make a 2 page PDF because there's no money for it

Honestly

⬐ Jensson

The fact that the teaching material is so horrible is probably the biggest reason learning programming is so easy, because if the teaching material would be any good then the CS grads would actually know difficult things and it would be harder for me to compete. But as is it is trivial to learn what they did, because they don't learn much. For programming it didn't take me long to learn programming well enough to get into Google and work on services with a million QPS or distributed machine learning training, because programming is really really simple. Not because you are good at teaching, no, I just sat and learned on my own just writing programs, all program tutorials and helps were horrible.

> But this is impossible, because, as I learned today, "math is a small field without money for things like this".

Of course it isn't impossible, that was never the problem here. Mathematicians have written plenty of such cheat sheets, you can find them everywhere just by Googling. Here is one for physics:

https://en.wikipedia.org/wiki/List_of_common_physics_notatio...

Here is one for math:

https://en.wikipedia.org/wiki/Glossary_of_mathematical_symbo...

Can you please understand that you are complaining that nobody created something that many many people have created many times over? I found those by googling "physics notation" and "math notation". Was that really too hard for you? If you want a cheat sheet specific for CS related papers, then that cheat sheet has to be written by someone with a CS background since a mathematician wont know what is useful to you, and neither will he know what quirky notation CS people use in their own papers since every domain of math has its own quirks.

What you are doing here is the equivalent of a guy wanting to learn python, and then going to the C++ comitee and complaining that no language is well documented online, and even when the C++ committee nicely shows you that in fact there is documentation of python online you still complain and say that nobody cares about your woes because that python documentation was in fact not easy enough for you to read!

⬐ klibertp

> because programming is really really simple

Millions of programmers that work hard and for a long time to master their trade are just dumb for not learning it instantly, like you. Poor bastards, deluding themselves they do somehow advance the field, while in reality programmers are just doing "tabs vs spaces" over and over again, and any kind of advancement is given to them by our benevolent mathematical overlords.

No. We've worked for decades to make programming this simple. You're driving an obviously overpowered car in a race, but choose to conveniently forget about its specs once you win.

> Mathematicians have written plenty of such cheat sheets, you can find them everywhere just by Googling. Here is one for physics

Sure they were created. I never said they weren't, so please stop insinuating that. I (not GGP) said specifically:

> It has literally nothing to do with explaining the syntax *close to where it's used*.

And that is not being done, so I really don't understand how the rest of the paragraph has anything to do with me.

> say that nobody cares about your woes because that python documentation was in fact not easy enough for you to read!

So? What's wrong with that? Are you telling me I'm dumb? Is it really all you can do?

Well, it's either that I'm simply an uneducated idiot, or that the documentation indeed could be better. You seem to default to the former. Well, I feel differently about that.

⬐ Jensson

> So? What's wrong with that? Are you telling me I'm dumb? Is it really all you can do?

No, I am saying that people take a long time to understand this. Programmers expects things to have a simple explanation behind it since in programming everything does have a simple explanation, since computers can only do very few things. But in math you quickly expand to concepts beyond, even as early as calculus you add infinities and continuous quantities and how to work with those, you can't ever program those things since those operations cannot be expressed using finite instructions. There is no "this function performs an integral on this other thing and is expressed using these steps of operations".

For example, lets say you want to sum 1/N^2 for N from 1 to infinity. How would you express that? You can't do it in a loop, since the loop never ends. You can stop at an arbitrary point, but how do you know that stopping there results in a good value? You can't, unless you do the math, calculus is a good tool to solve that. With it we can show that summing 1/N results in an infinite result, while 1/N^2 settles on a value and creates a way for you to calculate that value with error bars.

⬐ klibertp

> you can't ever program those things since those operations cannot be expressed using finite instructions.

And now you're telling me that Mathematica, Maple and the like don't exist. Yeah, we can't express the concepts directly, but if we're very good at one thing, it would be emulation.

> How would you express that?

Like this:

    >>> from sympy import *
    >>> i, n, m = symbols('i n m', integer=True)
    >>> # For example, lets say you want to sum 1/N^2 for N from 1 to infinity. 
    >>> Sum(1 / n ** 2, (n, 1, oo))
      ∞
     ____
     ╲
      ╲   1
       ╲  ──
       ╱   2
      ╱   n
     ╱
     ‾‾‾‾
    n = 1

Would do the same with the integral. There's even that strange elongated S and everything...

⬐ Jensson

You didn't program the sum, you just created a program that looks like the math symbols.

⬐ klibertp

I said: emulation. You don't actually need to stretch your mind to infinity to reason about it, right? I mean, you're not a matrioshka brain the size of a star, right? (Just making sure) So if your mind can cope with infinities by using just the very finite storage accessible to you, what prevents computers from doing the same? Like this:

    >>> summation(1 / n ** 2, (n, 1, oo))
     2
    π
    ──
    6

Dunno, seems legit? How come it appeared, even though my computer has only 32gb of ram, waaaay too little to hold infinity?

EDIT: obviously, I still didn't program it myself! I'm dumb, after all. But someone apparently did.

EDIT2: and that person also made sure that even the dumber coders (like me) can use, and benefit from, the tool they wrote.

⬐ Jensson

A computer understands instructions. You can give it instructs to loop and sum values. Those aren't instructions telling the computer what an infinite sum is. Math is about making humans understand such concepts, we have yet to be able to program those concepts.

For example, when you write a sum in python then the computer will sum the values and do the work for you. But when you write an infinite sum like that, you the human still has to do all the math work figuring out what to do with it, so you didn't circumvent the need to do math at all. The computer doesn't understand the sum. You can program simple simple rules for it to try to simplify it, but it still isn't nearly as versatile as a skilled human. For example this problem is a basic problem from a first year course, it makes sense that someone programmed in the human derived solution for it, but they haven't actually programmed the logic for infinite sums into the computer.

⬐ klibertp

> The computer doesn't understand the sum.

That's obvious? Computers don't understand anything. They're just machines. What did you expect?

> you the human still has to do all the math work figuring out what to do with it

Yeah. But with this tool, as dumb as I-the-human am, I am able to do that math even if I don't understand it, but more importantly I also have a much better chance of understanding what's happening. That's because the explanation is close to the place where it's needed (in a docstring, one key press away) and it is expressed in a way that I'm most familiar with (as code).

You're going to tell me that if I want to use math, I have to let go of every preconception I had and crawl into Plato's cave, to see the light in the darkness. I'm too dumb to do this, unfortunately, and a little bit too busy. It took me almost five years to really master C++ programming after all, while you skimmed Stroustrup's book and went on to write Qt the next day.

> but they haven't actually programmed the logic for infinite sums into the computer

They did. Just not the whole of it. Are you sure it's impossible to improve to the point where a skilled human no longer holds the definitive advantage?

Computers can't understand anything. But they are very good at blindly following the rules. The question is not what to do to make computers understand infinity, but what set of rules can emulate the real thing well enough. We're getting there. Maybe in another 100-200 years CS will swallow maths, who knows?

⬐ Jensson

> That's obvious? Computers don't understand anything. They're just machines. What did you expect?

They do arithmetic's perfectly.

> You're going to tell me that if I want to use math, I have to let go of every preconception I had and crawl into Plato's cave, to see the light in the darkness.

No, math is a huge with an extreme amount of flexibility and power. You have lists of solutions like this one, you can add those in a program and then have the program look them up and spit out answers, with maybe some simple algebra testing:

https://en.wikipedia.org/wiki/List_of_mathematical_series

But nobody will be able to just program all solutions to all math problems like that, or give you a bible of everything to look up, as nobody knows what math is useful to you specifically. This is why every field that applies math tend to create their own subfield in math, like mathematical physics or chemistry or statistics or computer science. They create their own compendiums of useful notation and results that you can use. Nobody understands even a fraction of all of that and where it is useful, instead you will have to understand what discipline the paper you are reading is coming from, usually noted somewhere on the paper, and then look that up. For someone doing computer science you mostly look at the subfields statistics, probability, combinatorics and algorithmic complexity. Most of those papers will be written by people who do math mostly on the side though, not pure mathematicians. Pure mathematicians mostly works on problems that are too abstract for programming. (Pure vs applied, probability statistics and combinatorics are examples of applied math fields).

Edit: So from my perspective the main problem you have is that CS professors have yet fleshed out and formalized the subfield Computer Science math. When I studied higher level physics all the math was taught by physics professors, since mathematicians doesn't understand that math, it is mostly developed by physicists. Why doesn't CS do the same? You can't expect mathematicians to do that work for your field, as there are too many fields depending on math and too few mathematicians to handle everything.

⬐ klibertp

> They do arithmetic's perfectly.

So does abacus. Even something like this: https://www.youtube.com/watch?v=GcDshWmhF4A is capable of doing arithmetic. Does that mean that the marbles somehow understand what addition is?

> look them up and spit out answers,

Wolfram Alpha does this, and let me tell you: things I couldn't understand listening to lectures and trying to work through handbooks (well, most of them were hand-me-downs from the '60s, so take that as you will), became clear in just a few days of work. I didn't cancel my subscription for 2 years after that, out of gratitude.

But, most of the papers out there don't use interactive platforms for publishing. Even though they could. But as you said, that would be too much work, so they simply don't. I accepted it, it's all good now.

> Pure mathematicians mostly works on problems that are too abstract for programming.

I was pretty sure we're not talking about "pure" math. I mean, we both agree that that particular branch is of interest to a tiny minority. Of course the pure mathematicians can stay inside their ivory tower forever, nobody cares. Notice that I repeated the word "use" multiple times. I was trying to imply having a goal that's not mathematical in nature.

EDIT:

> Why doesn't CS do the same? You can't expect mathematicians to do that work for your field, as there are too many fields depending on math and too few mathematicians to handle everything.

I... don't know. That's a very good question. Yes, teaching math in CS depts is generally outsourced to mathematicians. It was like that for me. You may be right, that could be the reason to all my problems.

So, you mean that if we want to have math that's understandable for programmers, we need to make it ourselves? Fair enough if so, I think.

⬐ Jensson

> Wolfram Alpha does this, and let me tell you: things I couldn't understand listening to lectures and trying to work through handbooks (well, most of them from the '60s, so take as you will), became clear in just a few days of work. I didn't cancel my subscription for 2 years after that, out of gratitude.

Wolfram Alpha didn't program everything, but it includes most things you will see in an undergrad. In my undergrad we used a 500 page reference book containing most of the formulas and notations of STEM undergrad programs, wolfram alpha is basically that book written as a program.

> I was pretty sure we're not talking about "pure" math. I mean, we both agree that that particular branch is of interest to a tiny minority. Of course the pure mathematicians can stay inside their ivory tower forever, nobody cares. Notice that I repeated the word "use" multiple times. I was trying to imply having a goal that's not mathematical in nature.

But then your main problem are mostly with computer scientists or statisticians math papers, not mathematicians. The problem with papers written by people who apply math is that usually they don't really understand the math, they just apply it, so they can't explain it well. There isn't much you can do about that. And papers written by pure mathematicians, they sure do understand what they do, but it uses mountains of abstractions in order to make the problem possible for a human to reason about so it wont be easy to understand either.

For example, most who study statistics views the math as a tool to solve problems. They wont put in the effort to fully understand it, and can therefore just give you the second hand explanations they learned themselves, and the result is that those explanations likely will be missing a lot of things. Pure mathematicians however wont understand the way you want to use the math as a tool, so they might have a full explanation or the math but they wont understand how to apply it in your field, so their explanations will also be bad. What you need is someone who did the work to study the pure math side, and then did a lot of work applying math, and then explain it. Such people are extremely rare though. I went that route, I knew a few others who did, but most of those I know didn't. They either went pure or applied, not both.

⬐ klibertp

> wolfram alpha is basically that book written as a program.

Exactly! Which is why I love it, and why I think it would be good to extend it to encompass more than just that one book, too.

> The problem with papers written by peo I went that route, I knew a few others who did, but most of those I know didn't. ple who apply math is that usually they don't really understand the math, they just apply it, so they can't explain it well.

This is already a third time you said something that made me really think again about the issue...

It sound very plausible. I think I've probably never even seen a proper maths paper. I've been struggling with math, but it didn't occur to me that a part of the reason (other than me being dumb) was that the authors struggled with it too! Were I in their place, I would definitely also try to reduce the amount of explanations to the absolute minimum, so that there's less of a chance I'll be called out for it.

EDIT:

> I went that route, I knew a few others who did, but most of those I know didn't.

I'm not joking, this is very serious: is it possible to learn from you somewhere/somehow? Because you're incredible, honestly, your patience is not running out even now, this deep into comments thread; and you really can speak in programming - this much I can see - and I think you're at least as competent on the other side (though I obviously can't judge it myself, so I'm deferring to (your) authority that I came to believe in). I'd be incredibly happy if I could somehow get a bit of your help.

(Seriously, I'm not sarcastic or anything, this is 100% honest. EDIT2: well, I still disagree with you on some points :P but I think if it's from you, I wouldn't have a problem with actually listening to you)

⬐ Jensson

> Exactly! Which is why I love it, and why I think it would be good to extend it to encompass more than just that one book, too.

I agree with this. Just that writing such programs is hard, it isn't something anyone can do.

> I've been struggling with math, but it didn't occur to me that a part of the reason (other than me being dumb) was that the authors struggled with it too!

I studied both theoretical physics and pure maths to a grad level. You really notice how the physics professors struggles explaining the math and gloss over things, while the mathematicians doesn't. The physicist are experts at solving and reasoning about physics problems, not maths, as soon as the math solves their problem they stop thinking about the math. It is a part of the reason I went to math afterwards, I wanted better explanations.

> I'm not joking, this is very serious: is it possible to learn from you somewhere/somehow? Because you're incredible, honestly, your patience is not running out even now, this deep into comments thread; and you really can speak in programming - this much I can see - and I think you're at least as competent on the other side (though I obviously can't judge it myself, so I'm deferring to (your) authority that I came to believe in). I'd be incredibly happy if I could somehow get a bit of your help.

I think I have some mental disability where my feelings don't remember things. So even though I hated some of your other comments that doesn't mean anything about other things. I just like discussing things and explaining, taking my time to think etc.

If you want to talk about something you can reach me at {removed}. I'll remove this later. I don't really care much about people learning who I am, but I don't want it to be obvious. I love discussing things, but few people really like discussions like this. So just hit me up and we can talk. I don't always have the right views and opinions, but I never stop thinking about arguments or reasons. I just changed my mind so many times that by now I've seen most arguments and it is rare to change my mind more now.

Edit: You can ask me about math or anything.

⬐ klibertp

> I think I have some mental disability where my feelings don't remember things.

You're not the only one - I also hated some of the things you've said about programming; I couldn't help it, programming is a large part of my identity, so I got defensive really fast.

But that doesn't matter, I mean, we're just talking here, I think none of us has really any bad intentions, and I really benefited from this exchange a lot. And it's not like you wanted to specifically hurt me with what you said, so even if I felt hurt I won't cry you a river because of that :)

> If you want to talk about something you can reach

Thank you! Saved it. The thing is, I have this inferiority complex caused by not understanding much about math even if I try to learn it. In college I was already good at programming, so I didn't have much interest or need to learn math back then. And later, when I realized that it would actually be a good idea to learn some, I found myself completely alone with it. I mean, nobody around me cared at all, there were no lecturers to go and ask questions to, no peers that would be solving the same problems at the same time, nothing, just the Internet, Wolfram, and a lot of head banging. I realized too late that I've made it this hard for me basically myself.

But what's done is done, so I started thinking about how to cope with the situation. And I came up with the idea that if someone explained maths to me in terms I'm familiar with from programming, it would be much easier for me to digest. But, there are no materials like that. That's understandable given the very specific path you'd need to take to be able to write or create them... And you've taken that exact path. Honestly, at this point I wouldn't mind you calling me an idiot and programming a children's game, if only I could understand the things that were eluding me for years.

Again, thank you. I will write an email, definitely.

⬐ Jensson

> You're not the only one - I also hated some of the things you've said about programming; I couldn't help it, programming is a large part of my identity, so I got defensive really fast.

Also, although I'm saying that learning programming is relatively easy, it is a field that is hard to master. The difficulty isn't understanding what a function does, but understanding how to architect a huge complex system so that you can still reason about it afterwards. Those systems will all be made up of those simple instructions though. That is different from math, in math the systems you invent often are entirely new things and can't get divided into simpler things.

"of all time" is often too strong of a qualifier for me. I would say "talks that I want to rewatch the moment they come to mind."

Charlie Kaufman's Bafta Lecture https://www.youtube.com/watch?v=eRfXcWT_oFs

Gabor Mate, Prisoners of Childhood https://www.youtube.com/watch?v=H9B5mYfBPlY

I consider Bret Victor's inventing on principle a non-technical talk, so yeah that. https://www.youtube.com/watch?v=PUv66718DII

Quel Solaar, on creativity https://www.youtube.com/watch?v=MJmqaWq7PJY

Probably Bret Victor - "Inventing on Principle" (2012) - https://www.youtube.com/watch?v=PUv66718DII

⬐ tppiotrowski

This is it!!! Thank you.

⬐ rheeseyb

Bret Victor is our idol! I didn't even have to click the video to know exactly which one you were talking about :)

⬐ tppiotrowski

I've been working on a WebGL project that had extremely low frame rates to start with and refused to give up until it rendered in real-time because of this talk. It's one thing to make something useful but I think the real measure of success is if it's useful and the value is created in real-time like you've done. Congrats!

Time and Time and Space and Space are necessary for high quality creativity : https://www.youtube.com/watch?v=Pb5oIIPO62g

and working with solid principles, from first principles, is how you reach durable new understandings. IMO.

The Seven Habits of Highly Effective People has some great material about the use of principles in being personally creative.

Inventing on Principle: https://www.youtube.com/watch?v=PUv66718DII

I serve as a creativity coach to builders, innovators, and founders. Sometimes what a thinker needs more than anything else is a BREAK to BATHE! and then... EUREKA! https://en.wikipedia.org/wiki/Eureka_(word)

In terms of mind-expanding or intellectually stimulating, I find it's easier to get that from Youtube. I recommend:

3blue1brown for math (https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw)

Everyday Astronaut if you are casually interested in rockets (https://www.youtube.com/channel/UC6uKrU_WqJ1R2HMTY3LIx5Q)

Bret Victor (https://www.youtube.com/watch?v=PUv66718DII&list=PLS4RYH2Xfp...) or Rich Hickey (https://www.youtube.com/watch?v=f84n5oFoZBc&list=PLXsqD83He-...) for programming and design.

Doing a full college course is such a time investment and it usually takes a few weeks to start proving the interesting stuff. I find it more fun to look to shorter content for inspiration. I might realize I don't understand the fundamentals of the topic and then seek out a way to study it.

Is a heftier compile step totally fine?

The biggest difference between PHP and Java in my mind is that you start Java and pay the compile cost on server start, in PHP you pay the compile cost on every request, frameworks and language features increasingly hide this future cost in caches but caches are one of the two hardest things in computing and often act like pushing things under the carpet, why optimise the compile? It's under the carpet

As we move closer and closer to Java's model, we get further and further away from that quick PHP feedback loop of, make a change press f5 see the changes immediately and quickly

Which puts us further and further away from the kind of ideals that Bret Victor mentioned in his very good talk inventing on principle: https://youtu.be/PUv66718DII which to quote: "Creators need an immediate connection to what they're creating."

Inevitably this is coming and is already here but we should recognise what we've lost

⬐ agustif

Meanwhile with something like NextJS/TypeScript/React you can just enjoy instant reloads without ever caring about F5 again

The more languages the better IMHO though

⬐ purerandomness

Did you just deliberately redefine 'reload' just to incite a flamewar, or do you really not know what's different in your example?

You’d probably like Bret Victor’s inventing on principle talk: https://m.youtube.com/watch?v=PUv66718DII

He demonstrates some good examples.

I’m not quite sure it’s what you mean by visual, but it seems obviously valuable and tools that enabled some of what he shows would be really useful.

I’m not sure why we don’t have these things - I think Alan Kay would say it’s because we stopped doing real research to improve what our tools can be. We’re just relying on old paradigms (I just watched this earlier today: https://www.youtube.com/watch?v=NdSD07U5uBs)

⬐ optymizer

Bret's talk was great! Thank you for sharing it.

⬐ fossuser

His website also has some great stuff: http://worrydream.com/#!/LearnableProgramming

⬐ caleb-allen

Thanks for the Alan Kay talk, I really enjoyed that.

Bringing two concepts closer, especially visually will result in a better developer experience - Thus merging html and js into a single file, component, class / object and sequential logic was really the turning point to build more complex web apps. This reminds me of the excellent talk by bret victor https://www.youtube.com/watch?v=PUv66718DII

Game code doesn't need player interaction either to hotreload. See this section of a talk by Bret Victor for some inspiration: https://www.youtube.com/watch?v=PUv66718DII&t=10m42s

⬐ aaron-santos

https://www.reddit.com/r/programming/comments/ryd1z/notch_pr... inspired me too. (JRebel for reloading).

I was inspired to work on this by Bret Victor's "Inventing on Principle" lecture https://youtu.be/PUv66718DII

Any feedback appreciated!

Nice, but I think I can raise you. That talk mostly seemed pretty predictable (though I incorrectly guessed gfx via sixels[0], not a(nother) terminal emulator). If your interest was piqued with that parent video though, prepare to have your mind blown with this[1], who’s thesis maybe similar in the sense of “stop _just_ simply working”. Bernhardt seems to be saying don’t be afraid to take time and think deeply and “go deep”, while Victor is explicitly saying make it count by way of targeting with intention what’s important to you. A sort of “fight the good fight.”

[0] https://en.m.wikipedia.org/wiki/Sixel

[1] https://youtu.be/PUv66718DII?t=625

You might find this talk by Brett Victor interesting: https://m.youtube.com/watch?v=PUv66718DII#

⬐ julienreszka

Thank you that was very interesting !

Bret Victor's Inventing on Principle talks a fair bit about how the greats don't solve what are thought to be the pre-existing problems of their field, but find solutions for problems no-one else even realized was a problem.

https://www.youtube.com/watch?v=PUv66718DII

The genius is a genius by the first look he casts on any object. Is his eye creative? – Emerson, Representative Men

(That seems related to Emerson's remark that though he didn't have a musical ear, he had musical eyes. I like that.)

⬐ winchling

Thanks!

SixthSense Technology (oldie but goodie): Pranav Mistry - https://www.ted.com/talks/pranav_mistry_the_thrilling_potent...

Inventing on Principle: Bret Victor - https://www.youtube.com/watch?v=PUv66718DII

I think most here have already seen it, but I find that Bret Victor's Inventing on Principle talk[1] is one of the best I've seen.

I re-watch it every so often to help prevent my thinking from falling into a rut. When developing software as a career, it's so easy to just fall into a pattern where you use the same tools and techniques over and over again.

Watching this talk this talk inspires me to investigate alternate approaches to developing and delivering software. It's easy to think of software development as something that always need to involve code, and nothing but code. But watching this talk inspires me to go and try things like Node Red and Unreal Blueprints. In both cases, code is usually still involved, but they both offer a visual way of connecting components. I find it helpful to be able to visualize software this way so I can immediate understand how data flows through the application.

[1] https://www.youtube.com/watch?v=PUv66718DII

I think the next game-changing evolution in programming languages is moving beyond plaintext.

Our basic building blocks of programming has not changed essentially since the beginning of programming.

We still treat programs as nothing but a bunch of files and folders edited with the same tools that writers use to write romance novels (yeah yeah "intellisense" is not so intelli at the end of the day).

We don't create beautiful images by writing RGB values in a text editor. We shouldn't be creating highly complex software systems with them either.

We need model based editing environments that will allow us to have a much richer set of software building blocks.

We have to allow software to be more than just characters in files. Software "source" is not a book. It's the blueprint for a system that has metadata and constraints attached to it. It can't comfortably and forever exist in a flat plaintext structure for human consumption.

If you are interested go dig up my old comments I have written more elaborate rants about it before.

And yes I'm ready for the inevitable and customary "NO IT AINT GON WORK WE TRIED BEFORE AND IT AINT WORTH TRYIN EVER EVER AGAIN" replies.

Also relevant:

https://www.reddit.com/r/nosyntax/

(I actually somewhat accidentally and indirectly caused the creation of the subreddit as a result of a discussion here on HN before)

https://isomorf.io/

https://en.wikipedia.org/wiki/Structure_editor

https://en.wikipedia.org/wiki/Intentional_programming

https://www.youtube.com/watch?v=PUv66718DII

⬐ gt_

“We’ve tried it before” is a poor excuse, of course. The theory angle holds both some better excuses for not getting our hopes up and possibly some clues on how to get there.

We’ve got to avoid taking text for granted. Basically put, the adaptability, precision, fastidiousness, accessibility, etc. of the written word makes the modern world possible. Phonetic type is far and wide the greatest communication interface known to man.

I work with a lot of node-based softwares doing CGI and post-production work. A few of the daily softwares I use have a small editor in the bottom corner of the GUI. The node interfaces are very useful and hard to live without. I agree that, when doing visually-based work, it feels very off to have to stop what I’m doing and so scripting. It feels like a vastly different mode of the mind. But, as I’ve gotten better at scripting, (still not great) I have noticed that when I have a visual idea with no implementation, it can be a good time to start building it with a script. I have roughed put some 3D scenes in scripts from the start and found this to be a totally different experience than the stop and change modes issue. I can’t argue for it’s productivity level, and I don’t know what the value of this observation is, but I honestly enjoy working this way when I do it. It’s as if my visual sensory system is relaxed and my imagination is utilized more. The ideas are parameterized rather than experienced. This does not happen with node interfaces, which actually introduce an extra visual experience. I am just babbling at this point, but these observations feel relevant. I do not, however, know what kinds of conclusions to draw from them.

⬐ gt_

One more thing... I do want very badly a plugin for a code editor that allows me to click and drag on a float (in code) and scroll it up and down. If anyone has any ideas or tips, please post! If it doesn’t exist, any thoughts on an environment or editor that would be friendly to such a plugin would also be helpful.

⬐ spiralganglion

Take a look at Bret Victor’s Tangle project. I believe there are editor plugins that offer this, but I can’t name any off the top of my head.

⬐ gt_

Thank you!! On a short vacation rn but will look into this in a couple of days.

⬐ borplk

I will add, remember the problem is not with text itself.

I'm not saying "text bad visual shiny fancy stuff good".

Text is great. But "textual representation" of a rich model/object is different than text being the very raw basic building block of something.

When text is your basic block it means we end up effectively sharing a language with the computers.

This creates lots of complex and somewhat unnecessary problems (for example "syntax", and "parsing").

It's also inappropriate because if you try to make the language better for the computers it quickly gets noisy and unreadable for humans.

If you try to make it good for humans it becomes difficult and ambiguous for the computers.

So you end up in this pointless fight.

You have to detach these two things from each other so that the computers can have a precise representation for themselves and humans can have a adaptable dynamic representation for themselves.

Imagine this paired with a system like the one Bret Victor demos in "Inventing on Principle" [0] or in "Stop Drawing Dead Fish" [1], in which the user hand-animates what they want the game movement/overall gameplay to look like, adjusting as necessary. The system described in this paper could get you a decent way from that hand-animated mockup to a working game that looks and feels first and foremost like you intended, rather than working from a playable-but-bad-feeling prototype game engine and having to endlessly adjust to get the game feel "right".

[0]. https://youtu.be/PUv66718DII?t=29m20s [1]. https://youtu.be/ZfytHvgHybA

⬐ bigleagueposter

Looking at the paper the set of games it can build seems rather limited. It could work for cookie cutter platformers (the sort of games that engines that don't require programming let you build).

True, it's kind of a shame that more of the features from Bred Victor's demos haven't made it into mainstream IDE's, such as:-

Inventing on Principle - https://www.youtube.com/watch?v=PUv66718DII (He has a handful of great demos on Youtube and Vimeo).

Another interesting source is Epic's Unreal Engine Dev tools - https://www.youtube.com/watch?v=DshYHUvLaDc

No, they explain that LabVIEW and other visual languages are just different ways of representing the code. The idea here, I think, is that there's far greater coupling between the output of the program and the program itself. It's similar to some of Bret Victor's ideas: https://www.youtube.com/watch?v=PUv66718DII

I'd like to incorporate this coupling idea into my own visual dataflow language (http://web.onetel.com/~hibou/fmj/FMJ.html), but haven't yet decided how to implement it. My approach has been to design the language from the bottom-up, so that simple programs can be simply drawn, and there are higher level programming constructs which simplify more complex code, avoiding the complexity problem (the Deutsch limit) you've seen with LabVIEW.

⬐ ezyang

Here is a transcript of the talk: https://github.com/ezyang/cusec2012-victor/blob/master/trans...

⬐ nkrumm

Are there any efforts do implement his "immediate feedback" ideas in the context of data science/scientific computing?

I could see some amazing iPython/jupyter demos, where the user can import some data, filter/rearrange data, and create a few plots-- but then adjust and see the plots change dynamically by adjusting values throughout the notebook.

⬐ Yenrabbit

I've seen a few, such as https://atom.io/packages/hydrogen - running code inline in atom with Jupyter.

⬐ koenbok

I like to think we are: http://framerjs.com.

⬐ trevyn

(2012)

⬐ dang

Yup. Added.

⬐ azeirah

So, where are all the companies that are building next-generation developer tools and direct manipulation document and simulation tools? It has been a while since this video got released.

⬐ tolmasky

We're building tonicdev.com (similar to iPython/Swift Playgrounds). A lot of these ideas are very difficult in the general case. For just one example, we spent a long time reasoning about time traveling (and came up with what we think is a great model for it - which takes into account the entire system including the filesystem, but it took considerable engineering effort and bleeding edge OS tools like CRIU: http://blog.tonicdev.com/2015/09/10/time-traveling-in-node.j... )

⬐ okket

Xcode/iOS Swift Playgrounds is pretty close.

http://www.apple.com/swift/playgrounds/

⬐ ontouchstart

The iPad Playgrounds uses a new bundle format called .playgroundbook

I have been exploring it in the past week and am very impressed.

https://mobile.twitter.com/ontouchstart/status/7584320300362...

Since Swift3 feature list is now finalized (https://apple.github.io/swift-evolution/), many of them will go into iPad playgrounds soon.

I am sure it will become great tool to learn Swift language as well as UIKit at many different levels.

⬐ amelius

My guess: developer tools are being developed in open source now. It is not financially interesting for companies to build developer tools.

⬐ pjmlp

Yes, FOSS somehow killed the development of software tools for anyone but the enterprise.

Given that many prefer to build something with duct tape than to pay for tools, the only ones left are the enterprise customers which hardly blink when they compare the tool's prices versus overall project costs.

One just needs to see the angry mobs on HN when JetBrains, Unity, Microsoft and others announce price changes.

Whereas on most enterprises I worked for, it is just a request to the Controller overseeing the project area.

⬐ doublerebel

I built the PixiJS playground [1] to teach myself how (WebGL/Canvas interactive framework) Pixi works in a practical manner.

Many of the variables can be changed live in the REPL or with sliders as the code is running. Images can be dragged and dropped into the browser for sprites.

I built reactive (pre-React) Pixi components to make this possible. Victor's work is definitely an inspiration.

In the end I used the components and knowledge to build a touch-compatible shelf-configurator for a client selling shelving products.

[1]: http://pixijs-playground.nextorig.in

⬐ jasonlaster11

We're working on a new Firefox debugger wtitten in react-redux, which we hope will be a platform for prototyping interactive/visual features.

https://github.com/jlongster/debugger.html

⬐ afhammad

http://witheve.com

⬐ fit2rule

Take a look at the music-making industry, specifically all the synthesizers and DAW-style apps popping up on iOS. Those folks have been paying attention to Bret ..

⬐ dominotw

There is time a traveling debugger in elm

https://www.youtube.com/watch?v=vS3yzUo7l8Y

Never really worked well in practice though, it falls apart once you use a 'port'. This was all back then not sure if things have changed.

⬐ endergen

Redux is the closest infrastructure that enables this stuff. The time travel aspects at least. Hot code reloading has definitely gone mainstream and if you look at a lot of the popular ones and trace their influences, many mention inspiration from Bret Victor.

⬐ abcampbell

Think you are missing (what I understand to be) his point.

The point is not that this is the UI of the future, the point is that there are other ways to conceptualize doing knowledge work with a machine, this is one.

Real innovation takes time...

Here's the man himself, Alan Kay, on the topic.

http://www.fastcodesign.com/3046437/5-steps-to-recreate-xero...

⬐ hacker_9

His demos only work with small amounts of code, scale up to the size of a real codebase and they all become infeasible, as well as not really that useful.

⬐ pjmlp

You mean like the code at Xerox PARC and ETHZ?

Many of his ideas were already possible on the workstation OSes created there.

⬐ endergen

Agreed. But possible and popularized are two different things.

⬐ pjmlp

Since I started delving into computer archeology I wonder how the computing world have looked like if AT&T had been allocated to sell UNIX instead of having given it for free.

⬐ endergen

I think patterns of developmental and good tooling make it scale up at least in utility to larger projects. Worse case use the workbench analogy like the clojurescript oriented devcards project where you check in playground style simple environments that are designed to make it interactively developing sub systems and components easy.

⬐ pbadenski

I’m developing Halik - time traveling debugger for JVM inspired by Learnable Programming. Emphasis on the ability to explore and visualize your program. See http://meet.halik.io.

⬐ daredevildave

PlayCanvas are doing this. Live development for WebGL across all devices simultaneously. https://m.youtube.com/watch?v=PS4oMLPyYfI

⬐ vincentriemer

Using something like React-Hot-Loader & Redux-Devtools gets you pretty close for browser work.

⬐ cma

When Swift was first announced it showed off a lot of stuff that was inspired by it.

⬐ pjmlp

Apple has Swift Playgrounds as someone described.

Visual Studio has edit-and-continue, interactive REPL, visualizers, some sort of backtracking and now from Xamarin Interactive Workbooks.

Then you have the whole INotebook trend which started out with Python and nowadays supports multiple languages.

However all these tools are actually catching up with many of the features that Smalltalk-80, Interlip-D, Mesa/Cedar, Lisp Machines, Oberon already had.

This is what Bret Victor jokes about in another presentation of him, where he pretends we are in the 70's making predictions how the world of computers will look like in the 21st century.

The future of programming, https://www.youtube.com/watch?v=8pTEmbeENF4

⬐ seanmcdirmid

Those experiences are not provided in smalltalk and Lisp machine, they are just a bit more interactive than others. In fact, playgrounds are inspired by inventing on principle and come closest to realizing just one of the demos, while the designs were obviously not around in the early 80s to guide anything.

You can definitely do "something" in smalltalk, lisp machine, but the experience was always hazily defined, and anyways, is quite niche. So as you resort to in your post, people tend to list technical features other than describe experiences, which, even after many of Bret's essays, still need further development before they are realized in production systems (we still don't really know what we want to do, especially what will scale beyond say playgrounds). Experience first, features that can realize it second.

> An open question is "Is being purely functional, even excepting I/O, worthwhile?" Or is it, as was suggested to me via email earlier this year, the equivalent of writing a novel without using the letter 'e'?

This is a great question. I've been playing with pure functional programming, and I also noticed that applying it to video games is very hard. In other areas, FP provides many advantages such as testability and safe parallel execution. But for simple games these are not that useful. Simple games seem very well suited for the imperative, global state model.

There is one aspect that might make FP worth it for games and it's interactive programming. The immediate feedback loop described by Bret Victor [1], with the possibility of going back and forth in time is easier to achieve with a pure functional approach.

The Elm debugger [2] is an implementation of this concept, using hot swapping and functional reactive programming it's possible to design games interactively in a very unique way that it's hardly achieved with the traditional imperative approach.

[1] https://www.youtube.com/watch?v=PUv66718DII [2] http://debug.elm-lang.org/

⬐ Peaker

> But for simple games these are not that useful. Simple games seem very well suited for the imperative, global state model.

I think this indicates a bias -- resulting from years of programming games in these models.

I think pure FP in the form of FRP is a far better match for simple games than the imperative, global state model.

⬐ the_af

> But for simple games these are not that useful. Simple games seem very well suited for the imperative, global state model.

Could you elaborate? I think this is one of those things we "know" which isn't necessarily so. Simple sprite-based games can be written using purely functional techniques (see: https://github.com/nikki-and-the-robots/nikki). It's just that it's not common to use FP languages for this.

⬐ ceronman

Yeah, I know you can develop games in a purely functional fashion. My point what is the advantage of doing so, given that most resources are developed for an imperative way. I think the interactive approach taken by Elm is a very good advantage of FP for games.

⬐ baggers

A few notes:

- Elm dropped frp [0]

- Even in it's older frp incarnation, elm didnt allow changing of the flow graph (sorry I cant remember the correct elm term for this) while the program ran [1], making it hard to say this would be an ideal way to go for true 'interactive coding' for games.

To clarify my opinion I would like to add that I am assuming an ideal of 'interactive game coding' where one would start a GL context & repl session at the start of the day and make the game whilst never closing the session or killing the context.

The OP limited himself to retrogames which is a wise move for exploring this topic, _one_ of the things that makes writing modern games hard is the extent to which you are pushing what the hardware can do. It is normal to be required to really be strict about what happens when in each frame and it's not possible to do this if, part-way through rendering you have to process events coming from some input thread that has no idea about the context your program is in.

Lastly I would add that your program itself is state. Interactive programming requires you to create and remove functions from your running program and bugs particular to doing this can occur (some object has a reference to a version of a function you have removed etc etc). Unless we move to a point where our code (compiled & text) live in a some persistant data-structure that allows rollback in some meaningful way I find it hard to imagine _real_ functional interactive programming.

This is a cool topic and ripe for discussion and progress, but just dropping in interactive programming does not in itself make game coding easier. However it is a pile of fun.

[0] http://elm-lang.org/blog/farewell-to-frp [1] https://www.youtube.com/watch?v=Agu6jipKfYw

You may not consider him a genius. But Bret does have some pretty innovate ideas on Programming and Design (and more). Good examples:

Inventing on Principle: https://www.youtube.com/watch?v=PUv66718DII

The Humane Representation of Thought: https://vimeo.com/115154289

Probably not exactly what you need, but as far as inspiration is concerned, it doesn't get much better than this:

http://www.youtube.com/watch?v=PUv66718DII

Check out Bret Victor's talks in general (worrydream.com). He is quite interesting.

Also check out this presentation of Bret Victor: https://www.youtube.com/watch?v=PUv66718DII

Pretty interesting stuff, especially given this happened a few years prior to today's release of Playground.

For those who don't get it:

1) Note that this page about Apple is by Bret Victor.

2) Take a brief look at this Bret Victor presentation - https://www.youtube.com/watch?v=PUv66718DII

3) Look at what Apple announced today - https://developer.apple.com/swift/

4) consider whether this might mean that some of the things Bret worked on at Apple might finally be seeing the light of day

5) discuss

I'm impressed that it looks like they're turning Bret Victor's demo into a reality with playground. Check out his demo if you haven't: https://www.youtube.com/watch?v=PUv66718DII

Really, really interested and excited about learning Swift.

⬐ capnmalarkey

Wouldn't say I'm impressed but definitely really excited. BVictor is pretty amazing. Anyone who hasn't seen should check out either these talks. There're great for getting extra inspired about coding or the coding life, and great for perspective too:

The Future of Programming: http://bit.ly/1pNtKMh Inventing on Principle: http://bit.ly/1opRrJp

⬐ None

None

⬐ tdicola

Yes, it's funny that people didn't pick up on Apple potentially doing more with it when his demo made the rounds a few years back.

⬐ magicalist

Why would they "pick up on" it? That was almost two years after Bret left Apple and it's been another two years since. At this point these ideas are as available to anyone as they are to Apple.

⬐ epsylon

It's funny that people never seem to think about IPython. It has a lot of this kind of stuff.

⬐ DanielRibeiro

Which is also similar to Elm's time travel debugger: http://debug.elm-lang.org/

Direct link to Elm's demo similar to Bret's: http://debug.elm-lang.org/edit/Mario.elm (video: https://www.youtube.com/watch?v=RUeLd7T7Xi4)

Is this related to Bret Victor's stuff? My mind was blown when I saw this video 2 years ago, and I can't help but see similarities here:

https://www.youtube.com/watch?v=PUv66718DII&t=10m42s

⬐ None

None

⬐ kmfrk

Bret used to work at Apple. I don't believe in coincidences. :)

Bret Victor's talk in question: http://youtu.be/PUv66718DII

I love the design and the concept of the site as well as others in this space like jetstrap, easel, and divshot. To be honest, I've tried a few of these offerings and as a web developer this is not what I want, I'm looking for two things:

1. An editor like the one Bret Victor talked about in his "Inventing on Principle" talk[1]. I want to edit HTML and CSS and see updates reflected in real time[2].

2. A way to hook this into a DVCS (Or better yet, a desktop application/desktop plugin). My development workflow relies heavily on Git and I don't think I'm going to download a zip payload and extract it every time I need to do a commit.

[1] - http://www.youtube.com/watch?feature=player_detailpage&v=PUv...

[2] - http://livecoding.io/

⬐ woah

1. Any static site generator with livereload. Try Docpad or Middleman.

⬐ joeblau

Wow! Thanks for the livereload link, I'm definitely going to implement this. I know people have been complaining about HN lately but it's contributors like you who continue to enlighten me with new tools that I love about this community.

Summary of the links shared here:

http://blip.tv/clojure/michael-fogus-the-macronomicon-597023...

http://blog.fogus.me/2011/11/15/the-macronomicon-slides/

http://boingboing.net/2011/12/28/linguistics-turing-complete...

http://businessofsoftware.org/2010/06/don-norman-at-business...

http://channel9.msdn.com/Events/GoingNative/GoingNative-2012...

http://channel9.msdn.com/Shows/Going+Deep/Expert-to-Expert-R...

http://en.wikipedia.org/wiki/Leonard_Susskind

http://en.wikipedia.org/wiki/Sketchpad

http://en.wikipedia.org/wiki/The_Mother_of_All_Demos

http://io9.com/watch-a-series-of-seven-brilliant-lectures-by...

http://libarynth.org/selfgol

http://mollyrocket.com/9438

https://github.com/PharkMillups/killer-talks

http://skillsmatter.com/podcast/java-jee/radical-simplicity/...

http://stufftohelpyouout.blogspot.com/2009/07/great-talk-on-...

https://www.destroyallsoftware.com/talks/wat

https://www.youtube.com/watch?v=0JXhJyTo5V8

https://www.youtube.com/watch?v=0SARbwvhupQ

https://www.youtube.com/watch?v=3kEfedtQVOY

https://www.youtube.com/watch?v=bx3KuE7UjGA

https://www.youtube.com/watch?v=EGeN2IC7N0Q

https://www.youtube.com/watch?v=o9pEzgHorH0

https://www.youtube.com/watch?v=oKg1hTOQXoY

https://www.youtube.com/watch?v=RlkCdM_f3p4

https://www.youtube.com/watch?v=TgmA48fILq8

https://www.youtube.com/watch?v=yL_-1d9OSdk

https://www.youtube.com/watch?v=ZTC_RxWN_xo

http://vimeo.com/10260548

http://vimeo.com/36579366

http://vimeo.com/5047563

http://vimeo.com/7088524

http://vimeo.com/9270320

http://vpri.org/html/writings.php

http://www.confreaks.com/videos/1071-cascadiaruby2012-therap...

http://www.confreaks.com/videos/759-rubymidwest2011-keynote-...

http://www.dailymotion.com/video/xf88b5_jean-pierre-serre-wr...

http://www.infoq.com/presentations/Are-We-There-Yet-Rich-Hic...

http://www.infoq.com/presentations/click-crash-course-modern...

http://www.infoq.com/presentations/miniKanren

http://www.infoq.com/presentations/Simple-Made-Easy

http://www.infoq.com/presentations/Thinking-Parallel-Program...

http://www.infoq.com/presentations/Value-Identity-State-Rich...

http://www.infoq.com/presentations/We-Really-Dont-Know-How-T...

http://www.mvcconf.com/videos

http://www.slideshare.net/fogus/the-macronomicon-10171952

http://www.slideshare.net/sriprasanna/introduction-to-cluste...

http://www.tele-task.de/archive/lecture/overview/5819/

http://www.tele-task.de/archive/video/flash/14029/

http://www.w3.org/DesignIssues/Principles.html

http://www.youtube.com/watch?v=4LG-RtcSYUQ

http://www.youtube.com/watch?v=4XpnKHJAok8

http://www.youtube.com/watch?v=5WXYw4J4QOU

http://www.youtube.com/watch?v=a1zDuOPkMSw

http://www.youtube.com/watch?v=aAb7hSCtvGw

http://www.youtube.com/watch?v=agw-wlHGi0E

http://www.youtube.com/watch?v=_ahvzDzKdB0

http://www.youtube.com/watch?v=at7viw2KXak

http://www.youtube.com/watch?v=bx3KuE7UjGA

http://www.youtube.com/watch?v=cidchWg74Y4

http://www.youtube.com/watch?v=EjaGktVQdNg

http://www.youtube.com/watch?v=et8xNAc2ic8

http://www.youtube.com/watch?v=hQVTIJBZook

http://www.youtube.com/watch?v=HxaD_trXwRE

http://www.youtube.com/watch?v=j3mhkYbznBk

http://www.youtube.com/watch?v=KTJs-0EInW8

http://www.youtube.com/watch?v=kXEgk1Hdze0

http://www.youtube.com/watch?v=M7kEpw1tn50

http://www.youtube.com/watch?v=mOZqRJzE8xg

http://www.youtube.com/watch?v=neI_Pj558CY

http://www.youtube.com/watch?v=nG66hIhUdEU

http://www.youtube.com/watch?v=NGFhc8R_uO4

http://www.youtube.com/watch?v=Nii1n8PYLrc

http://www.youtube.com/watch?v=NP9AIUT9nos

http://www.youtube.com/watch?v=OB-bdWKwXsU&playnext=...

http://www.youtube.com/watch?v=oCZMoY3q2uM

http://www.youtube.com/watch?v=oKg1hTOQXoY

http://www.youtube.com/watch?v=Own-89vxYF8

http://www.youtube.com/watch?v=PUv66718DII

http://www.youtube.com/watch?v=qlzM3zcd-lk

http://www.youtube.com/watch?v=tx082gDwGcM

http://www.youtube.com/watch?v=v7nfN4bOOQI

http://www.youtube.com/watch?v=Vt8jyPqsmxE

http://www.youtube.com/watch?v=vUf75_MlOnw

http://www.youtube.com/watch?v=yJDv-zdhzMY

http://www.youtube.com/watch?v=yjPBkvYh-ss

http://www.youtube.com/watch?v=YX3iRjKj7C0

http://www.youtube.com/watch?v=ZAf9HK16F-A

http://www.youtube.com/watch?v=ZDR433b0HJY

http://youtu.be/lQAV3bPOYHo

http://yuiblog.com/crockford/

⬐ ricardobeat

And here are them with titles + thumbnails:

http://bl.ocks.org/ricardobeat/raw/5343140/

⬐ waqas-

how awesome are you? thanks

⬐ Expez

Thank you so much for this!

⬐ X4

This is cool :) Btw. the first link was somehow (re)moved. The blip.tv link is now: http://www.youtube.com/watch?v=0JXhJyTo5V8

Bret Victor: Inventing on Principle

http://www.youtube.com/watch?v=PUv66718DII

⬐ dfield

I second this. Actually, I'm an even bigger fan of his "Stop Drawing Dead Fish" talk, but unfortunately I don't think it is online yet.

⬐ bjeanes

The talk isn't released yet, but he spoke on similar topics at strange loop https://thestrangeloop.com/sessions/taking-off-the-blindfold

⬐ Permit

This talk alone convinced me to attend CUSEC 2013. It's a fantastic demo.

⬐ shurcooL

This talk defines who I am.

⬐ seanmcdirmid

Ah, that reminds me:

http://lambda-the-ultimate.org/node/4715

You might like it.

⬐ pokpokpok

do the tools he was using currently exist? especially the first two

⬐ None

None

⬐ sideproject

This guy is my hero.

⬐ msutherl

A friend of mine invited Bret to do this talk. He told me that Bret sent close to 50 emails leading up to the event making sure that every aspect of the talk was perfectly choreographed.

⬐ hbrundage

Mr Leavitt is the coolest.

If you are a skeptic on this, I really urge you to listen to Bret Victor. I have generally been skeptical of these kinds of things in the past, but just in the last week Bret Victor's talk (http://youtu.be/PUv66718DII) combined with his excellent 2006 paper that digs into related concepts (http://worrydream.com/MagicInk/) has made me re-think that position.

One of the key points in his talk that made me think about this more is that there are whole avenues of exploration that are completely inaccessible when the feedback loop is as long as it is with current programming techniques.

I think it depends highly on the kind of programming you do. The more closely related your programming is to math (e.g. engineering simulations or stats), the less likely you are to see an issue because you're directly manipulating the "stuff" you're working on. But if you write software that operates more in the human space (e.g. something like an email client), then you're acutely aware of how far removed the code is from the user and what the program does. You basically have to keep a giant mental model in your head as you code. That is a huge cognitive load that all of us take for granted as part of "programming" but why must this be so?

⬐ mattmanser

I'm skeptical because I remember the RAD tools of the early 00s that were going to let businessmen program.

Oh, and who can forget the wonderful workflow systems that were all the rage soon after? There seemed to be a new one released every week.

I invite you to go try MS's WWF, that's 'visual'. What a nightmare that is.

They don't work. You need a programmer involved because edge cases rapidly become complicated and that's the hard bit, not visualizing a workflow. And these tools deprive you the programmer of the fine grained control you sorely need or worse generate code that's so hard to read and work with that it's faster coding from scratch even for amateurs.

I love Bret Victor's vision, but because of what it means for programmers, not the fuzzy 'creatives' in the article. I know some animation guys and yes, you can visually automate things like animation now, but logic flow? No.

Though I think we should keep trying.

⬐ aufreak3

Unlike the "workflow systems" you mention, non-programmers make audio-visual art using Max/MSP/Jitter and kids make stuff using Scratch/BYOB. Both have been rather successful in engaging non-programmers of various age groups. So we do have evidence of "visual" interactive programming working well for some people.

⬐ mattmanser

I don't deny it's a useful learning tool, my first exposure to programming was a Turtle robot you could program to draw stuff when I was 5 or 6!

It's just a very, very long distance yet from producing the kind of code that we all produce day-to-day now.

⬐ aufreak3

I'm not sure what "kind of code that we all produce day-to-day" you're referring to, but Max being priced at $400 per license suggests it isn't only a "useful learning tool". Do checkout http://cycling74.com and see whether the long distance could be the other way for these kinds of applications.

⬐ endergen

I met with Bret Victor for lunch while visiting SF a few years ago and I specifically argued against visual programming languages making anyone able to program. I mean I know that some people are more inclined to think in blocks and visual metaphors (Hell most programmers draw out ideas constantly cause we do too) but any sufficient program eventually gets complicated enough that visual programming kind of breaks down unless it gets more and more abstract to make reusable components and modules that you can navigate too etc. I pushed at the time and I'm not even sure he remembers at this point but for augmenting text based programming and making what's happening more visual and real-time. Which seems to be some of the direction he's taking which is combining his great ideas in visualization with traditional text based programming environments. I was also a huge fan of Javascript as the lingua franca despite it's deficiencies because web based IDEs and examples were inherently so much more shareable than code you had to download and try (There could be ways around this such as a desktop repository of code viewer, but that's a friction point to people actually checking out demos/examples interactively ala JSBin as such.)

I'm personally loving what Kahn academy is doing that John Resig credits Bret Victor's talk on Inventing on Principle (http://vimeo.com/36579366) as a major inspiration. See article where he announces and explains their in browser interaction learning of CS course material: http://ejohn.org/blog/introducing-khan-cs/

In closing to name a view limitations of most visual programming languages: the naming problem (Most parts of your system need to be named in order to be able to talk about them), text based is stronger at this. Instantiation of reuseable code is pretty abstract to do visually. Eventually all programming gets complicated enough that text based approach really is easier to work with. Not to mention all the tools you can't leverage comparitvely to text based such as version control, REPLs, etc. I guess I think visual programming is idealized and people are spending all this time learning something that isn't as useful to know in the long term compared to traditional programming because all the important platforms have much richer support for text based programming (iOS, linux, C/C++ for games). But combining visualization of code execution is the perfect balance and would lead to basically replacing much commenting with an actual intuitive visualization of runtime complex structures/state. And definitely real time feedback of tuning /visual parameters is great. In the game industry all of this is very standard and I do feel there is a little more awe for his work than would be given by your typical graphics, art tool, or demo scene programming devs. Most game development toosl for say level editing and animation are all highly visual and real time interactive. Same goes for any serious AI dev they have debugging tools for visualizing all planning for entities communication, path planning, animation states, and more.

Anyway, just my thoughts. Still think Bret Victor is one of the most compelling thinkers in this space.

⬐ bunderbunder

Just listened to a Herding Code interview with a guy who was using APL to get domain experts programming.

He had a very interesting and elegant solution to the problem: You let the domain experts take charge of implementing their domain logic. But as soon as you hit a point where what they're doing needs to be shared with the rest of the company, you bring in a software engineer to sit down with them and review the code. They take charge of making sure it's robust and reliable, and work with the domain expert to refactor it into something that will be more maintainable.

That seemed like a reasonable solution to me. And the thing that was striking was that he wasn't doing it with any newfangled visual languages or anything like that. It's already being done successfully in a business environment using APL.

⬐ edtechdev

Intuitions and anecdotes are fine, but there is actual research on visual programming languages, as well as on computer science education.

Visualizations, animations, and metaphors do help beginners learning programming and understand programming concepts. Scratch is currently probably the most well known tool for beginning students to use for programming (used with kindergartners all the way up to college freshmen).

⬐ JoeAltmaier

Some people are helped by visual metaphors. Others learn by hearing; other by reading.

And then there was that thread about some people never, ever 'getting it' and being as hopeless after a semester class as the first day. I've even met folks who, after years of computer classes, still hadn't figured out that code is executed in sequence.

⬐ edtechdev

Actually a lot of research over the past few decades has shown there is not really evidence for 'learning styles' - that one person might be a visual learner, and another an auditory learning, and so forth.

Learning isn't just about sensing (hearing, viewing), anyway, it is more about action. What are the students actually doing, and what can students do with a particular tool. Actually everything we perceive is tied to what we do (see: enactivism, embodied cognition, ecological psychology).

Many students aren't 'getting' programming in CS classes partly because it is not taught well (if instructors switched from lectures to active learning techniques, student retention and learning might double or triple, based on research in other domains), partly because the tools themselves are not designed especially well or are not designed with beginners in mind (including python and java), partly because it is often taught devoid of any context (see, situated learning and situated cognition), partly because of low student self-efficacy (what you mentioned - thinking they just can't learn this stuff), and tons of other reasons.

⬐ JoeAltmaier

Oh come on - I personally know people who've hired readers in college because they absorb more efficiently through hearing it spoken aloud. Others despise pictures - they want written descriptions. Some the other way around.

Rationalize it any way you want - they learn faster and better one way than another, measurably.

And about bad teaching: the whole class gets it, but a few. The teacher is clearly not addressing their needs, but they are also clearly not doing it 'wrong' - many do understand just fine.

⬐ bluedanieru

I first got into programming using Hypercard on the machines at my middle school. I started out just visually building simple stacks that didn't really do much, until a teacher showed me some of the stuff older kids had built by manipulating the Hypertalk language underneath. It was like learning about the Matrix. I looked at what they did and copied it for my own stuff, eventually learning a significant portion of the Hypertalk language. Fun times.

As such, I think 'visual' programming might be great to rope people in, but it isn't enough. Had I not taken it to the next level, I would have gotten bored, simply because I couldn't do that much with the tools I knew about. Drilling down a bit was hard, but necessary. In the case of Hypercard, of course I had to drill down because the tools for putting together complicated stuff visually weren't there. But, there is a reason they weren't there, that being that Hypertalk, while having a steeper learning curve than buttons and slides, was a more efficient and concise way to represent more complex stuff.

There's really no way around that. At its best, visual programming can be a way for non-programmers to put together really, really, simple stuff that they think they need. (It can be much worse than this, I've worked with a framework that was originally designed for this purpose or something like it, for middle office banking software - worse 18 months of my fucking life, and the worst part was none of the non-programmers it was originally targeted towards would go near it.) For everything else we need more robust tools.

And let's not forget that the hard part of programming isn't even the syntax anyway. It's the concepts. Even if you could design a visual programming 'language' just as rich as any text-based one, anyone who wanted to do anything with it would still have to learn all the same concepts. And that's the hard part.

⬐ JunkDNA

I guess I tend to think about it like this: is the current state of the art for programming the best that we can ever do? If the answer is "no" (which it most certainly is), then what does the future look like? Great strides have been made in shortening the "edit, compile, run, test" feedback loop because it's recognized that this saps creativity and flow the longer the amount of time it is. The natural progression of that is instantaneous feedback (excitement about Christ Granger's Light Table shows this).

Once you have instantaneous feedback, the next logical step is some kind of direct manipulation. Visual programming (at least as currently imagined) may not be the right kind of direct manipulation, but there simply has to be a better way than typing text in one window and seeing the output in another.

I think lots of the comments here are thinking too much about visual programming metaphors that have been bolted onto existing programming paradigms. I suspect those are clunky because existing programming paradigms are clunky when represented visually. I'm not sure that means that in the universe of possible programming paradigms, there doesn't exist some form that is better when represented visually.

⬐ sbmassey

Any programming paradigm is going to at minimum have something like an if statement.

Say you wanted to do something when two items compare equal, in text you could write something like: if (a == b) { ... }

With a visual metaphor, you are going to have to have some way of setting up entities representing the 'if', and the '==' predicate, along with references to wherever 'a' and 'b' are defined, and a way of getting to the block of code that executes when the condition is true.

I find it hard to conceive that any kind of direct manipulation of code at this level is going to be better than text, whether you're trying to understand it or modify it.

I grant you visual tools for manipulating higher level stuff like data schema's, gui's, and so forth work well, but I'm guessing they'll always need text for the underlying logic.

⬐ emelski

I'm skeptical because I don't see how visual programming models are even possible for the type of development I routinely perform (my day job is writing a high-performance distributed, parallel implementation of the well-known 'make' tool). Even if it is theoretically possible, for some parts of my project, I imagine it would take nearly as long to create the visual programming environment, and I'm not sure it would be particularly reusable.

I loved Bret Victor's talk. And this recursive drawing thing is neat too. But both of those are dealing with programs that are primarily visual in their own output. I can't help but think, "That's neat, but not broadly applicable." Honestly, how many people are there out there dying to write programs to make fractal-like pictures?

Perhaps I'm just not visionary enough to see the potential, but I don't believe these techniques will really "democratize programming." Whether or not doing so is desirable in the first place is another debate altogether.

Vim reminds me of an example from Bret Victor's excellent talk Inventing on Principle [1] (which you should watch from beginning to end if you've somehow been hiding under a rock and have missed it).

Bret mentions Larry Tesla (starting at about 38:10) who made it his personal mission to eliminate modes from software.

This is the problem I've always had with Vim and I suspect I'm not alone in this. I find the concepts of modes jarring, even antiquated. Everyone who has used vi(m) has copied and pasted text in while in command mode and done who knows what.

Emacs is better in this regard but I find Emacs's need to consecutive key presses (or a key press followed by a command) to be longwinded.

The advantage of either is they're easy to use over ssh+screen (or tmux) for resuming sessions.

That all being said, give me a functional IDE any day. IDEs understand the language syntax. Vim can do a reasonable job of this. Emacs (with elisp) seems to do a better job (or so it appears; I'm no expert) but IDEs (my personal favourite being IntelliJ) just make everything easier. Things as simple as left-clicking on a method and going to its definition.

For statically typed languages (eg Java/C#), IDEs (quite rightly) rule supreme. Static code analysis, auto-completion, etc are just so much better than text-based editors.

Dynamic languages are more of a mixed bag and its certainly the norm for, say, Python and Ruby programmers to use one of these.

Still, give me an IDE any day.

One objection seems to be that people don't like using the mouse. I tend to think the speed differences over not using the mouse are largely illusory.

Anyway, I can use vim but I've never felt comfortable in it and I don't think I ever will and modes are the primary reason.

EDIT: I realize there are plugins and workarounds for many of these things but that's kinda the point: I don't want to spend hours/days/weeks/years messing with my config to get it "just right".

Also, instead of archaic commands to, say, find matching opening/closing braces (which tend to involve an imperfect understanding of the language), IntelliJ just highlights matching braces/parentheses, where a variable is used and so on.

[1[: http://www.youtube.com/watch?v=PUv66718DII

⬐ aerique

Emacs is better in this regard but I find Emacs's need to consecutive key presses (or a key press followed by a command) to be longwinded.

These consecutive key presses ("chords") are just there to provide default bindings and are one of Emacs' weakest points since they're universally horrid. However, there's no single best way to use Emacs[1]: everyone should configure it how they want it to. After years of using my own key bindings I've streamlined them with the rest of my OS[2] and couldn't be happier.

[1] Opposite IMHO to Vi(m) where one should use the default key bindings.

[2] CTRL/CMD-o to open a file, C-s to save, C-f for incremental search, etc.

⬐ martininmelb

I used to use IntelliJ when I programmed in Java and loved it. I was still learning Java and its ability to show help, check syntax and refactor was excellent. But then I did less Java and more Python and returned to vim. One issue was that I was not only editing code, I was writing documents in LaTex, I was editing large 'data' files (ascii text), I was editing blogs and other notes in Markdown etc. Unfortunately, IntelliJ seems to regard everything as a project and does not make it easy (at least back then) to simply create or edit a file that is not part of a particular project.

Another advantage of vim is that most of the time at work I am working on a PC but editing files on Linux boxes. At home I am on a mac. I know I could run X, but I prefer running Putty, and I enjoy the lightweight nature of just bringing up vim. So, currently, vim is my editor of choice.

Also, I must admit that after 20+ years of using vi/vim, I still make the occasional mode mistake and type 'i' when in insert mode, or ':wq', but vim is still my favourite editor.

⬐ Ralith

Given that emacs (and I expect vim) can do all of that and then some, for languages both static and dynamic while taking a fraction of the resources of a monolithic IDE and permitting to use the same editor across all your projects, it seems that your only actual problem is that the default configs are not to your taste.

⬐ cageface

My laptop can run a full-featured IDE (IntelliJ) without breaking a sweat and it supports all the languages I need and then some.

I guess I could go back to trying to hack together an IDE in emacs or vim with a bunch of buggy, half-supported third party plugins that interoperate poorly if at all, but why?

⬐ Ralith

> My laptop can run a full-featured IDE (IntelliJ) without breaking a sweat and it supports all the languages I need and then some.

I've had a quad-core desktop chug under Eclipse (employer required I use it) and still had to fall back to a real editor regularly.

> I guess I could go back to trying to hack together an IDE in emacs or vim with a bunch of buggy, half-supported third party plugins that interoperate poorly if at all, but why?

Well, mostly people use the well-maintained, integrated, and first-party ones instead. Each to his own, I suppose!

⬐ modarts

"real editor"? As opposed to what?

⬐ Ralith

As opposed to IDEs, which are characterized by having tightly constrained domains and weak editing features beyond whatever language-specific functionality they bloat up their GUIs with.

⬐ modarts

An editing environment that makes it easy to develop in a specific domain doesn't make it any less "real" than any other environment.

⬐ irahul

> Everyone who has used vi(m) has copied and pasted text in while in command mode and done who knows what.

If you are using vim, you should play per vim rules. When you are entering text, you enter insert mode. When you are done, back to command mode. Once you have that mental model, you don't try to c-v(or c-shift-v or whatever) in command mode. Also, if you are willing to try vim, grab a vim build with clipboard support and copy-paste from within vim(=+p paste clipboard, =p paste x selection, =+y{motion} copy to clipboard ... in command mode; or ctrl-r+ paste from clipboard, ctrl-r paste from x selection in insert mode)

> I find the concepts of modes jarring, even antiquated.

The thing I like about vim is translating intent to vim commands - delete 10 lines and then move to the top of the file 10ddG, delete everything inside these parens and put me in insert mode cib etc. Without modes, these won't be as short and sweet. You will be left with long key combinations - the way emacs does it.

> Emacs is better in this regard but I find Emacs's need to consecutive key presses (or a key press followed by a command) to be longwinded.

Isn't that obvious? If you always want to be in insert mode, how else will the special instructions be entered?

> The advantage of either is they're easy to use over ssh+screen (or tmux) for resuming sessions.

And they are very good at editing text, and majority of programming languages, though might require some configuration.

> For statically typed languages (eg Java/C#), IDEs (quite rightly) rule supreme. Static code analysis, auto-completion, etc are just so much better than text-based editors.

I generally am able to find something for Vim which makes language specific stuff easy.

Clojure - http://www.vim.org/scripts/script.php?script_id=2501 Java - http://eclim.org/ Go - https://github.com/nsf/gocode C - http://www.vim.org/scripts/script.php?script_id=3302 Python - http://rope.sourceforge.net/ropevim.html

And a lot more...

> I tend to think the speed differences over not using the mouse are largely illusory.

Doesn't that depend on the task? What will be faster - ctrl-f on this page or clicking edit(or some menu)->find?

Also, for me, it is more about having my fingers on home row is the sweet spot and moving my fingers from my sweet spot is irritating.

⬐ flyinRyan

>If you are using vim, you should play per vim rules.

This issue is that studies show us vim's rules are wrong: modal editing is a source of confusion and error. I used vi[m] exclusively for 8 years or so and until the very last day I could still make major modal based errors.

⬐ antidoh

"This issue is that studies show us vim's rules are wrong:"

If using vim is wrong, I don't want to be right.

Honestly, I can believe such studies, and I still would use vim.

One, my shoulder gets tired and sometimes hurts if I move back and forth between keyboard and mouse too much.

Two, by the time I move to the mouse and back, I could have done the equivalent twice on the keyboard and moved on.

Three, there is nothing sweeter than "How did you do that?" :)

⬐ flyinRyan

>One, my shoulder gets tired and sometimes hurts if I move back and forth between keyboard and mouse too much.

>Two, by the time I move to the mouse and back, I could have done the equivalent twice on the keyboard and moved on.

Vim got this part right, and it ends up being better than Emacs in that regard: in Emacs you also don't need the mouse but all the chording requires moving the hands too much. Ideal would be to take Emacs' non-modal editing and combine it with Vi's simply edit mode: for example, say you are in "command mode" only if you hold down Caps lock, but when the button isn't held down the editor is always in insert mode.

⬐ irahul

> This issue is that studies show us vim's rules are wrong: modal editing is a source of confusion and error.

The so called studies show people who aren't used to modes are confused when using a modal editor.

> I used vi[m] exclusively for 8 years or so and until the very last day I could still make major modal based errors.

I have been using vim exclusively for 5 years now. And I stopped making modal based errors after 2 weeks. My anecdote cancels yours?

From what I have seen, people who leave vim in insert mode are the ones making mode errors. Insert mode isn't the rest mode for vim, normal mode is. You are bound to make errors when starting because out of habit, your mind assumes insert mode as the rest state.

⬐ flyinRyan

>The so called studies show people who aren't used to modes are confused when using a modal editor.

"Don't listen to this study, listen to my firmly held belief". That's not how this works. If you want to combat a study you need to do so with another one, not by just saying throwing out untested assumptions.

>From what I have seen, people who leave vim in insert mode are the ones making mode errors. Insert mode isn't the rest mode for vim, normal mode is. You are bound to make errors when starting because out of habit, your mind assumes insert mode as the rest state.

Thanks for the condescension. Have you ever started to type a word and had your hands just finish it for you? Sometimes there will be some relatively large word that I type out commonly enough that when my hands notice the first few letters of it they'll type it out automatically with me having to go back and delete it and type out the similar starting word I meant to write. I even recall having my hands do it again on the correction once.

Having this kind of muscle memory is a killer for vi usage. Lots of times I have intentionally left the editor in insert mode for just a second while I grab some text from, say, a website to paste in. What I didn't realize is that my hands knew to always get back to command mode when changing screens so even though my mind had tried to save keystrokes my hands defeated me. The result? Pasted a huge document into command mode. Great. Similar sync issues came up regularly enough that I typically mashed Esc 2-4 times (in case there was, e.g. a command active that would write in the Esc char) rapidly before starting anything to ensure that I was where I thought I was.

In my experience, I wouldn't get the time savings I should have been getting due to having to slow down for the mode management.

⬐ raphaelb

To be fair you didn't link these studies you speak of either. Modes never seemed to bother me very much and I've been using vim for a while but I can understand the difficulties with it.

Also it occurs to me that I may do some of those things like mashing esc repeatedly just to be sure subconsciously.

⬐ tincholio

> If you want to combat a study you need to do so with another one, not by just saying throwing out untested assumptions.

You can just show that the methodology is flawed, no need to repeat the experiments in all cases

⬐ irahul

> "Don't listen to this study, listen to my firmly held belief". That's not how this works. If you want to combat a study you need to do so with another one, not by just saying throwing out untested assumptions.

Yeah. Combat the studies that you totally provided the link to. Throwing claims around saying "scientists say that" or "studies have proved that" is surely not how it works.

> Thanks for the condescension.

What part was condescending? Leaving vim in insert mode causes errors? The rest state of vim is normal mode?

> Having this kind of muscle memory is a killer for vi usage for you

You are extrapolating personal anecdotes to absolutes.

⬐ ibotty

> Everyone who has used vi(m) has copied and pasted text in while in command mode and done who knows what.

try to set mousemode (vim) if vim is compiled with x11-support.

⬐ jes5199

The way that most Vim users use modes is like using "StickyKeys" on your Shift/Control/Option keys. You smack "i" or "a" to go into insert mode just for the duration that you need it, and then you smack Escape the moment that you stop typing, even if it's just pausing to think.

Also, if you use a GUI version of Vim, then it knows about "paste" and doesn't make the mistake of interpreting your paste buffer as keystrokes.

⬐ dave1010uk

I think this is the key to vim. It's a revelation or a turning point in how you use it. You change to insert mode to insert text; you don't change to normal mode (to do text operations) as you're already in normal model.

⬐ MichaelAO

Great talk - a lot to be learned in his approach to creation on a digital medium. His unique speaking style is awesome ha

⬐ Codhisattva

Definitely one of my favorite talks.

⬐ rithal

What inspiring and awe-inspiring talk! I discovered this video thanks to this post on HN http://news.ycombinator.org/item?id=4171058

The essence of trial-and-error, rather than going directly the outcome you want.

It's interesting that even Bret Victor's Inventing on Principle only accelerates trial-and-error, but doesn't eliminate it. http://www.youtube.com/watch?v=PUv66718DII&t=14m0s For that, you need a declarative understanding, and an analytic relation from outcomes to initial conditions

⬐ easy

I saw this linked from the 'the future is specific' light-table thread and thought it deserved a bit more attention.

In case anyone is wondering:

"Bret Victor - Inventing on Principle" (http://www.youtube.com/watch?v=PUv66718DII)

⬐ d0mine

Thank you for the link.

Make tools to be extensions of our bodies via immediate feedback is a useful idea (it is not the main point of talk, but it stands out to me).

As a side note: It might be even be literally true for physical tools i.e., a brain can physically change to see the tool as an extension of the hand (from a study about ape, its brain, and a stick).

⬐ destraynor

This talk is amazing, but has already done the rounds.

I am also missing the real-time simulation, after seeing Bret Victor's talk and his demo.

http://www.youtube.com/watch?v=PUv66718DII&feature=playe...

This is a demo from a talk presented by Bret Victor. The full video is here: http://youtu.be/PUv66718DII