
Ted Nelson on What Modern Programmers Can Learn from the Past [video] - rbanffy
https://spectrum.ieee.org/video/geek-life/profiles/ted-nelson-on-what-modern-programmers-can-learn-from-the-past
======
tboyd47
Anyone know where to find the full length interview? This is just a clip.

"We thought computing would be _artisanal_. We did not imagine great
monopolies."

In a sense, it still is, and always will be. I feel that the core of
programming, just making the computer do things other people want it to for
money, will always lead us back to a highly individualized workflow, where a
single programmer has complete mastery over the system. It's just that the
programmer-artisan must find work in the context of these great, monopolistic
organizations, which inevitably apply pressure to reduce the amount of skilled
labor required to perform a given business function, and thereby increase the
organization's leverage in salary negotiations, leading to hyper-specialized
assembly line processes that eventually just stop working because no one has
the broad systems-level knowledge required to trace a bug to its source
anymore. It would be great if these monopolies could just accept the artisanal
nature of software development and pay people what they're worth.

~~~
IpV8
People writing software are generally in the top 5% income level. Why do you
feel that they are not being paid what they are worth?

~~~
randomdata
I'm not sure that is generally true. The median software developer salary in
the US is $102,280[1]. An income of $100,000 puts you in the top 9.15%[1]. A
top 5% income writing software isn't completely unheard of, but it does not
seem to be represented by any kind of majority. There are always outliers.

[1] [https://www.bls.gov/ooh/computer-and-information-
technology/...](https://www.bls.gov/ooh/computer-and-information-
technology/software-developers.htm)

[2]
[https://en.wikipedia.org/wiki/Personal_income_in_the_United_...](https://en.wikipedia.org/wiki/Personal_income_in_the_United_States)

~~~
IpV8
Thanks for fact checking me, I should have done my homework first.

I still think that the 9.15% stat supports my claim though. I hang out with
mostly non-engineers so its a bit comical to be shamed by hacker newsians for
proposing that we get paid enough. Most studies on the matter have
demonstrated that any income over 75k has no correlation on happiness, so for
me I guess I feel more concerned about finding meaningful work than a higher
salary.

On another note, I am not sure why all of these people claiming to providing
value equal to 10x their salary don't simply work for themselves and see if
they can really rake in that much without the support of their company.

~~~
randomdata
I understand where they're coming from. Pay, of course, is a function of
supply and demand. Nothing more, nothing less. The greater the demand,
relative to the supply, the higher the price. We're constantly told that
developers in high demand and that companies cannot find anyone to hire, to
the point that the government has even pushed 'learn to code' programs to try
and bring more people into this 'future industry', so price should be rising
rapidly to close that gap... but it's not happening for the most part.

So we have this disparity where the market is not reflecting what the media
(et. al.) are reporting. I can see how that is leading to much confusion for
those in the industry.

In 2014, the median income for software developer, applications was
$103,054.85[1] (in 2017 dollars). Today, the median income for software
developer, applications is $102,212.06[2] (again, in 2017 dollars). Developer
incomes are on the decline.

It appears that we're reached equilibrium. If the industry was honest and said
"go away, the industry is full" people would have less belief that they're
worth more, but that's not the message we continue to hear.

[1]
[https://www.bls.gov/oes/2014/may/oes151132.htm](https://www.bls.gov/oes/2014/may/oes151132.htm)

[2] [https://www.bls.gov/ooh/computer-and-information-
technology/...](https://www.bls.gov/ooh/computer-and-information-
technology/software-developers.htm)

------
jorgeleo
"All I can say is: close your eyes and think what it might be. My first
software designs were largely done with my eyes closed. Thinking if I hit that
key what should happen if I hit that key..."

In my experience, this is a common characteristic of the 10x programmer. It is
not about frameworks, it is not about patterns; both things help, but it is
really about to be able to run the system in your head.

~~~
mwcampbell
Current real-world systems are too complex to simulate accurately in your
head. I've learned to assume that I don't really understand a system until
I've collected sufficient trace output from the real thing.

~~~
mattmanser
Are they? I "run" systems in my head all the time. I'm familiar with the code
base, from that I'll know roughly where the bug is. I can tell you which
function a bug will probably be in and how it's probably happening, just from
having the symptoms described to me.

Hell, even when I'm not familiar I can guess what's happening based on past
experience.

It's some sort of spatial ability, like navigating a map (though I recently
found out I'm terrible at visualizing and almost completely lack a 'mind's
eye'). I also find I rarely get lost in computer games and very rapidly learn
FPS maps.

Maybe's it's one of those weird skills you don't even realise some of the
population lack.

Personally I've always thought using traces are a massive crutch that are too
expensive in cost vs benefit ratio, I don't get the point. Far too many extra
lines of code for too little gain.

~~~
pharrington
We are literally weeks into Meltdown/Spectre. The code you write runs on a
complex programming language you didn't write, that may be running on a VM,
that is running on an OS, that is running on a multicore CISC processor with
100s of _publicly known_ instructions, that can only be built due to modern
developments in quantum mechanics.

You run _idealized_ versions of systems in your head.

~~~
esmi
"You run idealized versions of systems in your head."

Definitely true but running idealized approximations of systems [1] are also
sufficient, at least in my experience, to get a rough idea of where a bug
might be a majority of the time.

[1] We're basically describing
[https://en.wikipedia.org/wiki/Systems_modeling](https://en.wikipedia.org/wiki/Systems_modeling)

~~~
pharrington
Certainly. I guess my main objection was to the parent questioning whether
modern systems are "too complex to simulate _accurately_ in your head".
Effective programming, as you note, requires acknowledging that you are
approximating, and understanding the scopes and ramifications of those
approximations.

------
TedNelson
I wish IEEE would put up the whole interview. After all, I own the copyright
on those words. I am making inquiries about it.

Rather than reply individually to the misimpressions of my work on this Reddit
page, let me refer anyone who wants the true picture of my software
deliveries, design variations and former ambitions, to
hyperland.com/HTbrew-D11

Or you might look directly at two of my productions, Cosmicbook (2003, with
Ian Heath) xanadu.com/cosmicbook with visible links between pages-- you can
make them too-- and OpenXanadu (2014, with Nicholas Levin).
xanadu.com/xanademos/MoeJusteOrigins.html showing transclusions (origins)
only, no links. See above paper for further explanation.

I am not a programmer, but a designer-director of software (like Doug
Engelbart and Steve Jobs, but with far fewer resources). Every delivery is a
negotiated reduction of a vision against resources, technical restrictions,
and time. (Not to mention misunderstandings and disagreements.) It's like
directing movies, but with more options, more gotchas and less fun.

I am proud of the working stuff I've delivered and grateful to those
collaborators, and I haven't given up yet.

------
mpweiher
"How to see the possibilities when there are so many things around you that
are a certain way".

So much this, and this is something where trawling the old papers really,
really helps. So much there that we have either (a) forgotten or (b)
discarded, but forgot why we discarded it.

Now spending a lot of time trying to tell (a) from (b). Fun!

~~~
romaniv
I am constantly amazed by the productivity of top computing experts in the 60s
and 70s. They managed to accomplish so much in such a short time, while
working in small teams, on ridiculously slow hardware and having next to no
libraries or tooling.

In the corporate world today it often takes a dozen people and a few years to
create what's effectively a website that records user inputs to a database and
occasionally sends emails.

I understand that I'm comparing top programmers of the past to average
programmers today, but I think modern tooling and accidental complexity of our
computing environments plays a large part here as well.

~~~
_pdp_
The email was invented in 72. There you go!

------
dangirsh
My favorite Ted Nelson interview:
[https://youtu.be/RVU62CQTXFI](https://youtu.be/RVU62CQTXFI)

It gives a great perspective on Ted's prophetic vision for computers as well
as the intense skepticism it raised in many.

~~~
mentos
Incredible. I agree with the top comment on that video, the interviewer was
being pessimistic and not open minded but it served to make Ted Nelson expand
and give very comprehensive answers.

------
IrishJourno
Hi Folks -- you asked, we answered! Here's an 11-minute cut

[https://spectrum.ieee.org/video/geek-
life/profiles/extended-...](https://spectrum.ieee.org/video/geek-
life/profiles/extended-directors-cut-ted-nelson-on-what-modern-programmers-
can-learn-from-the-past)

------
miguelrochefort
Where are the modern-day Ted Nelson, Tim Berners-Lee, Douglas Engelbart, Alan
Kay?

It seems like all the great minds are building gimmicky apps and starting
ICOs.

~~~
kabes
I wouldn't put Ted Nelson on the same page like the other ones. The other
three actually build stuff that is now everywhere. Ted never got anywhere is
now bitching all the time on how much better his ideas were than what we
actually got.

~~~
DonHopkins
I think his biggest problem is that he refuses to collaborate with other
people, or build on top of current technology.

He's had a lot of great important inspirational ideas, but his implementation
of those ideas didn't go anywhere, he's angry and bitter, and he hasn't
bothered re-implementing them with any of the "inferior technologies" that he
rejects.

Back in 1999, project Xanadu released their source code as open source. It was
a classic example of "open sourcing" something that was never going to ship
otherwise, and that nobody could actually use or improve, just to get some
attention ("open source" was a huge fad at the time).

[http://www.theregister.co.uk/1999/08/27/web_precursor_xanadu...](http://www.theregister.co.uk/1999/08/27/web_precursor_xanadu_project_goes/)

>Register believe it or not factoid: Nelson's book Computer Lib was at one
point published by Microsoft Press. Oh yes. ®

They originally wrote Xanadu in Smalltalk, then implemented a Smalltalk to C++
compiler, and finally they released the machine generated output of that
compiler, which was unreadable and practically useless. It completely missed
the point and purpose of "open source software".

I looked at the code when it was released in 1999 and wrote up some initial
reactions that Dave Winer asked me to post to his UserLand Frontier discussion
group:

[http://static.userland.com/userlanddiscussarchive/msg010163....](http://static.userland.com/userlanddiscussarchive/msg010163.html)

[http://static.userland.com/userlanddiscussarchive/msg010164....](http://static.userland.com/userlanddiscussarchive/msg010164.html)

[http://static.userland.com/userlanddiscussarchive/msg010165....](http://static.userland.com/userlanddiscussarchive/msg010165.html)

[http://static.userland.com/userlanddiscussarchive/msg010166....](http://static.userland.com/userlanddiscussarchive/msg010166.html)

[http://static.userland.com/userlanddiscussarchive/msg010167....](http://static.userland.com/userlanddiscussarchive/msg010167.html)

A few excerpts (remember I wrote this in 1999 so some of the examples are
dated):

>Sheez. You don't actually believe anybody will be able to do anything useful
with all that source code, do you? Take a look at the code. It's mostly
uncommented glue gluing glue to glue. Nothing reusable there.

>Have you gotten it running? The documentation included was not very helpful.
Is there a web page that tells me how to run Xanadu? Did you have to install
Python, and run it in a tty window?

>What would be much more useful, would be some well written design documents
and port-mortems, comparisons with current technologies like DHTML, XML,
XLink, XPath, HyTime, XSL, etc, and proposals for extending current
technologies and using them to capture the good ideas of Xanadu.

>Has Xanadu been used to document its own source code? How does it compare to,
say, the browseable cross-referenced mozilla source code? Or Knuth's classic
Literate Programming work with TeX?

>Last time I saw Ted Nelson talk (a few years ago at Ted Selker's NPUC
workshop at IBM Almaden), he was quite bitter, but he didn't have anything
positive to contribute. He talked about how he invented everything before
anyone else, but everyone thought he was crazy, and how the world wide web
totally sucks, but it's not his fault, if only they would have listened to
him. And he verbally attacked a nice guy from Netscape (Martin Haeberli --
Paul's brother) for lame reasons, when there were plenty of other perfectly
valid things to rag the poor guy about.

>Don't get me wrong -- I've got my own old worn-out copy of the double sided
Dream Machines / Computer Lib, as well as Literary Machines, which I enjoyed
and found very inspiring. I first met the Xanadu guys some time ago in the
80's, when they were showing off Xanadu at the MIT AI lab.

>I was a "random turist" high school kid visiting the AI lab on a pilgrimage.
That was when I first met Hugh Daniel: this energetic excited big hairy hippie
guy in a Xanadu baseball cap with wings, who I worked with later, hacking
NeWS. Hugh and I worked together for two different companies porting NeWS to
the Mac.

>I "got" the hypertext demo they were showing (presumably the same code
they've finally released -- that they were running on an Ann Arbor Ambassador,
of course). I thought Xanadu was neat and important, but an obvious idea that
had been around in many forms, that a lot of people were working on. It
reminded me of the "info" documentation browser in emacs (but it wasn't
programmable).

>The fact that Xanadu didn't have a built-in extension language was a
disappointment, since extensibility was an essential ingredient to the success
of Emacs, HyperCard, Director, and the World Wide Web.

>I would be much more interested in reading about why Xanadu failed, and how
it was found to be inadequate, than how great it would have been if only it
had taken over the world.

>Anyway, my take on all this hyper-crap is that it's useless without a good
scripting language. I think that's why Emacs was so successful, why HyperCard
was so important, what made NeWS so interesting, why HyperLook was so
powerful, why Director has been so successful, how it's possible for you to
read this discussion board served by Frontier, and what made the World Wide
Web what it is today: they all had extension languages built into them.

>So what's Xanadu's scripting language story? Later on, in the second version,
they obviously recognized the need for an interactive programming language
like Smalltalk, for development.

>But a real-world system like the World Wide Web is CONSTANTLY in development
(witness all the stupid "under construction" icons), so the Xanadu back and
front end developers aren't the only people who need the flexibility that only
an extension language can provide. As JavaScript and the World Wide Web have
proven, authors (the many people writing web pages) need extension languages
at least as much as developers (the few people writing browsers and servers).

>Ideally, an extension language should be designed into the system from day
one. JavaScript kind of fits the bill, but was really just nailed onto the
side of HTML as an afterthought, and is pretty kludgey compared to how it
could have been.

>That's Xanadu's problem too -- it tries to explain the entire universe from
creation to collapse in terms of one grand unified theory, when all we need
now are some practical techniques for rubbing sticks together to make fire,
building shelters over our heads to keep the rain out, and convincing people
to be nice and stop killing each other. The grandiose theories of Xanadu were
certainly ahead of their time.

>It's the same old story of gross practicality winning out over pure idealism.

>Anyway, my point, as it relates to Xanadu, and is illustrated by COM (which
has its own, more down-to-earth set of ideals), is that it's the interfaces,
and the ideas and protocols behind them, that are important. Not the
implementation. Code is (and should be) throw-away.

>There's nothing wrong with publishing old code for educational purposes, to
learn from its successes and mistakes, but don't waste your time trying to
make it into something it's not.

~~~
tannhaeuser
> _Anyway, my take on all this hyper-crap is that it 's useless without a good
> scripting language. I think that's why Emacs was so successful, why
> HyperCard was so important, what made NeWS so interesting, why HyperLook was
> so powerful, why Director has been so successful, how it's possible for you
> to read this discussion board served by Frontier, and what made the World
> Wide Web what it is today: they all had extension languages built into
> them._

I'm wondering what your wiser, older self has to say about this 20 years on.
Isn't it useful that documents you wrote 20 years ago can still be read?

From my memories, the Web craze started well before JavaScript, and JavaScript
really only jumped on the bandwagon; so how could it be the critical success
factor for the Web?

The success of the Web and JavaScript in the last two decades speaks for
itself; but in 2018, JavaScript and the procedural Web could very well be its
undoing when considering the original goals of the Web, couldn't it?

~~~
dvanduzer
I don't think Don meant that JS was the critical success factor for the Web.
But that extensible scripting is crucial to the kind of Web Ted Nelson wanted
in the first place.

From my lived experience, the Web craze would be better termed the Modem
craze. And the critical success factor that turned it into the Web, was NSF
removing the restrictions on commerce in 1995.

JavaScript is just what got HTML closer to some ideals of Xanadu. Not close
enough for Ted's vision, but that is a broad sociopolitical vision.

~~~
DonHopkins
Server side scripting languages were critical to the success of the web,
before browser side JavaScript was available and matured.

Simple stateless perl cgi scripts forked from apache that talk to text
databases or mysql were the first simplest step, but things got much more
interesting with long running stateful application servers like Zope (Python),
Java, Radio UserLand, HyperCard, node, etc.

My favorite thing about node is that it lets you use the same language and
libraries and data on both the client and server side. That's an enormous
advantage that far outweighs JavaScript's disadvantages. But some people just
can't see or believe that, for whatever reason, and they're fine with flipping
and flopping back and forth between different languages, and hiring different
people to write multiple subtly divergent versions of everything in different
languages.

Face it: for all its faults, JavaScript won. I will always have a place in my
heart for FORTH, PostScript, MockLisp, ScriptX, TCL, Python, HyperTalk,
UserTalk, CFML, Java, and all those other weird obsolete scripting languages,
but it's soooo much easier to program in one language without switching
context all the time, even if it's not the best language in the universe. And
TypeScript is a pretty darn good way of writing JavaScript.

You're right, the web was held back until it was finally considered "ok" to
use it for commercial activity!

I'd say JavaScript is just what got HTML closer to implementing any ideal you
want, and there's no reason Xanadu couldn't be implemented on top of current
web technologies (except that Ted doesn't want to). But I don't think
extensibility and scripting itself was part of Ted's original vision or
implementation.

Just as so much has happened since MVC was invented (yet it's still
religiously applied by cargo-cult programmers), also so much has happened
since Xanadu was invented (like distributed source code control, for example),
which requires a total rethinking from basic principles. We also have the
benefit of a lot of really terrible examples and disasterous experiments to
learn from (wikipedia markup language, wordpress, etc). Many of Ted's
principles should be among those basic principles considered, but they're not
the only ones.

~~~
dvanduzer
Hmm, HyperCard in the same list as Zope and node? Interesting. :-)

The idea that JavaScript "won" is a little controversial to me. I think it's
huge and important, but the world is still changing. Embedded Python goes
places that Node still can't. I absolutely see the value you describe in
sticking to one ecosystem, but I don't think JavaScript/TypeScript/Node is the
only way to get those benefits. (See also: Transcrypt) I really enjoyed the
PyCon 2014 talk on the general subject:
[https://www.destroyallsoftware.com/talks/the-birth-and-
death...](https://www.destroyallsoftware.com/talks/the-birth-and-death-of-
javascript)

The most recent conversation I had with Ted was after someone had just
demonstrated the HoloLens for him and a few others. Ted had some feedback for
the UI developer, and it didn't have anything to do with JavaScript or that
level of implementation detail at all. It was all about the user experience. I
don't want to put words into his mouth, but like he says in this recent
interview, this is all hard to talk about because it really has changed so
quickly.

I do think you're right that a lot of what Ted wanted to see could be
implemented today in JavaScript and Git. But I think about the _technical_
meat of that vision to be about data-driven interfaces. I am simply not old
enough to _really_ understand how notions of "scripting" changed between the
60s and the 80s. But the fact that Xanadu was started in SmallTalk suggests to
me that scripting was part of the vision, even if a notion like "browser
extensions" might not have been in mind.

Completely agree that there are other voices to learn from, and other
important mistakes that have been made since Xanadu! (I think Ted would agree,
too.)

------
agumonkey
Something about how ideas in an era end up being distorded in the next one. It
seems like any important new thing shifts the gravity of society and thus
society itself. A cool idea in the 60s will become the root of a bad one in
the 70s. It's not linear

