[PREV - REPTILLIAN_MONOTHEISM] [TOP]
DINOSAUR_WARS
July 24, 2013
http://www.youtube.com/watch?v=JxAXlJEmNMg&list=PLK2r_jmNshM9o-62zTR2toxyRlzrBsSL2
Douglas Crockford's talk "The Early Years"
is fundamentally about the irrationality
of programmers, and appropriately enough, This talk is nominally part of a
it stikes me as somewhat nutty. series about JavaScript, but you
might not notice that from this
lecture.
He argues that programmers are
extremely conservative, refusing It leads off so boffo it's
to adopt good, new ideas until funny: punchcards? We need do
decades after they're developed; hear about punchcards again to
we all have to wait for a new get to javascript?
generation of programmers to
get into the game for a new He does eventually touch
idea to take hold. a few less familiar
bases, though, and
He tells a history of someone younger than I--
computers that emphasize cases like, the typical JS
that support his point; and he programmer-- might very
repeatedly dances away from well feel enlightened by
the parts that don't quite. all this.
An early religious issue:
Batch vs. Timeshare
The programmers familiar with
batch programming apparently
resisted moving to timesharing.
Crockford's take is they just hadn't
tried it, however well-reasoned they
thought thought their arguments were:
"... the main one came down to
*discipline*. Batch mode required CSG
where you had to think the whole
thing through and submit flawless That's an attitude that I associate
programs to the computer because with the original Computer Science
if it was buggy his. you'd never gang... they had a dismissive
ever get it to work--" attitude toward "hackers" because
hackers had an experimental approach.
So, we can score this one for And they preferred this-- strangely
Crockford's thesis. And idealized and romantic-- approach,
(looking ahead) we can also where everything must be
give him the goto controversy. designed-in-advance, you must,
Further, I can see why he visualize the whole thing, get your
thinks the slow but thorough flow charts straight, mathematically
triumph of OOP is a point for prove that your algorithms work, and
him (though myself I suspect only then start coding.
it's more complex than that).
The interative approach has
thoroughly won, at this point,
which is something to remember--
it sometimes seems that no one
ever wins these religious wars.
Crockford tells an interesting
story about how Intel had to give
up on their ambitious
ada-on-a-chip project (well, maybe
two chips... well, would you take
really-slow-ada-on-two-chips?);
they retreated to doing the more He skips the detail of
conventional 8086: it was designed the 8088, which let IBM
to be compatible, and to be cheap, roll out it's PC using
and it conquered the world, all largely 8 bit hardware,
but leaving architectures like the with 16 bits only in the
68000 in the dust. processor.
He blames the "lousy" intel At the time, I thought the
architecture on those damn 8088 was a marketing dodge,
programmers sticking with a way of advertising 16 bits
the familiar. while really providing only
8 bits-- but another way of
My take is nearly the opposite: looking at this is that it
backwards compatibility is gave IBM a natural upgrade
important, you abandon it at path to 16, and things like
your peril. Legacy matters, and that are not by any means
trying to break with it is often worthless.
just an insane ego-trip.
Crockford Comments on the
modern lack of innovation in
many fields:
hardware: Intel; powerpc; arm
OS: unix 70s; windows 80s I don't see any problem
there: when a problem is
He adds: "Where we do solved, you should stop.
innovation is in
programming languages"
And personally, I wish
they'd knock it off. We
have enough languages, and WEDDING_PARTY
I'd be happy to see several
decades of work just on
libraries and applications.
Unfortunately we seem to be wasting
a solid decade Going Mobile.
But no doubt my perception
that this is a nearly complete
waste is just another example
of a programmer's delusions, a
hidebound conservative attitude.
It's popular, it *must* be good.
We geezers have so much
trouble keeping up.
The shuffling zombies
getting in the way on
the train platform, the
people driving while
texting... I'm always
complaining about
*something*.
Can't wait to get your
hands on the new slyFad9,
eh? I hear it has
enhanced NSA-tracking
features.
Another of Crockford's tale of
the slow triumph of the good
over clinging to legacy is
Assembly vs high level:
This is an awfully ambiguous one,
even just taking it as Crockford
lays it out: many of the popular Crockford dicusses
machines of the day were extremely the example of atari
limited in capabilities, and game/computer systems
when efficiency is key, assembly at length, emphasizing
wins (or can win). their limited resources.
It's often the case that
the hardware must catch up
to the software.
It takes a generation to get
the bugs out, to figure out how
to use the shiney new toys, and
for hardware resources to
advance far enough to make some
inefficiencies moot.
Another case Crockford touches
on is the OOP debate.
He takes it as symptomatic that
there was so much resistance
and regards it as merely a
matter of ignorence.
UNINTENDED
Trying to deal with this issue-- or the
wider issues-- in any reasonable way
would be a mess... just defining what
it is you're talking is hard, everything
is a moving target. OOP may have won,
but are the OOP practices that won the
same as the ones that were originally The OOP intelligensia look
tried? (e.g. aggregation over askance at our attempts at
inheritence may be a common approach OOP-- so was it a fair trial,
now, but it wasn't the way OOP was or were we just doing it
originally sold). And haven't wrong?
conditions changed over the intervening
decades (hardware costs; plus social (The intelligensia always
factors... the expectations of other seem to have complaints
programmers and managers/customers)? like this-- the RDBMs we
have are not truly
*relational*, etc.)
For me, Objects (of a sort) have
won, and I was certainly a
reluctant convert. The thing is,
for me, objects are just one way Another problem: using
of sharing state between routines, present day popularity as
and if OOP wasn't a commonly an indication of quality
understood way, I would do it is weak. It presumes
some other way. that the current
generation of programmers
Whether an approach is know what they're doing,
the right or wrong way and Crockford insists
has a lot to do with how that the previous
many people *think* it's generation was clearly
the right way. out-to-lunch, so why
should we assume the
Software development present one is any better?
is a collaborative
social process, so
existing attitudes
are not just some
barrier to overcome,
they're the raw
material you have to
work with.
RIGHT_TOOL
In his history of languages,
he mentions Pascal briefly,
pointing out it became very He doesn't mention the flaws that
popular and was then abandoned, seemed obvious to me, e.g. it's
because of certain flaws. strings sucked. C's strings of
indefinite length seemed like a
Pascal is for me the critical great feature (though really,
example, it was the key thing quite dangerous: just a pointer
that taught me that hype is into memory).
often hollow. There are always
some very bright people out GENTLE_ART_OF_PROGRAMMING
there who seem very knowlegable,
and very sure of themselves and
they're not shy about promoting
their ideas as the biggest thing
since the zero. SILVER_BULLET
The beginnings of wisdom:
understanding how stupid
smart people can be. Has there ever been
a really successful
programming language Now, if Haskell
named after a were named
mathematician? after *Eddie*
Haskell, they
He complains about the amnesia of the might have
Java-community-- they lost as the something.
in-browser language, and reinvented
themselves as a server-side language--
Crockford finds it tremendously
significant that JS kicked this
one well-annointed ass, but Actually, as I understand it,
myself I think it just signifies the original idea was that it
how much Java sucked, not how was supposed to be an
cool JS is. embedded device-programming
language. Not being a mobile
I would complain about the kind-of-guy, I don't know how
amnesia of the Javascript well that worked, but I would
community: I suggest that it guess it's a player.
lost the first round also,
and pushed a lot of The main idea was it was
web-programming back to the supposed to be more reliable
server-side. It took the than C-code, and there it
invention of libraries like succeeded, because nothing
Jquery to smooth over the could be worse.
problems... Javascript may
indeed have Good Parts (TM),
but those alone are not the
reason it's winning for web
programming.
In the early days of the web,
netscape.com ruled the web
traffic, followed by yahoo in
second place. The netscape
people had the idea of beefing up
their functionality as a Portal,
but the Javascript they slathered
over it was so horrible it was
unusable. Yahoo took first place.
The perils of doing things
on "Netscape time".
(Maybe Jakob Nielsen has
a point about useability
testing, no?)
If you listened to Crockford,
you'd think every new idea is a
good idea, and you should never
go with the bird in the hand.
But there are many great new
ultra-hyped fads that have flopped,
and Java-in-browser is a good example.
Programming is a discipline
afflicted with intellectual fads,
and far from being horribly
reluctant to adopt innovations,
we often seem to be suckers for
every new shiney toy.
And there are many cases where
everyone has been excited to Have you noticed any
jump on something hyped as the skepticism about
next big thing, and then only "cloud computing"?
later do they figure out how to
make it work-- because otherwise
they'd have to admit they called
it wrong.
Often what happens is the
fad is *made* to work,
*after* it becomes popular.
To listen to Zak, Rails
was in horrible shape when
"Ruby on Rails" became the
next big thing.
(And actually, from this point of view the
Pascal debacle is an amazing triumph of
rationality, because the language was
abandoned-- this is a case where we were
collectively capable of realizing we had
made a mistake.)
There are a number of things Crockford touches
on that struck me as just curious anecdotes at
first: we have backspace and delete keys because
they were needed to deal with papertape; we use
CRLF pairs to terminate lines because they
descend from teletypes; vi users continue to use
hjkl to navigate because those were cursor keys
on a popular terminal...
I gather these things aren't just
supposed to be curiosities--
they're supposed to *offend* us,
we're supposed to *loath* the fact Calling emacs and vi
that web standards require using 'dinosaurs' tips his
a CRLF pair where a single character hand. He hates
would do. legacy of any sort.
My points:
o there's no simple answer
like new=good or old=better;
o There's no existing faction whose judgement
you can trust to evaluate new technology That is to say, the
supposed experts in the
o We have no mechanism for reliably field have at best a
evaluating ideas in this field. mixed track record in
offering advice.
THE_PROFESSIONAL_GOODMAN
Because of these difficulties, being EXPERTISE
cautious about experimenting with new
things is entirely rational.
KNOWLEDGE_IS_GOOD
--------
[NEXT - ZOMBIESCRIPT]