
“The Mess We're In” by Joe Armstrong at Strange Loop [video] - sgrove
https://www.youtube.com/watch?v=lKXe3HUG2l4
======
habitue
So, while in general I've enjoyed other things Joe Armstrong has written, I
think this talk is pretty discombobulated and doesn't have a coherent
narrative.

Here are some of the problems Joe posed:

    
    
      - bugs in software like Open Office, Keynote, grunt
      - code not being commented
      - computers booting slowly
      - computers using too much energy
      - code being written for efficiency rather than readability
    

He talks about distributed hash tables at the end. An interesting topic,
definitely cool, but they have nothing to do with the problems he posed
earlier.

This seems more like a disconnected list of gripes, plus a completely
unrelated list of things he currently finds neat to think about. Which is
totally fine, but I don't think it makes a particularly great talk.

~~~
mattholtom
Came here to see this. I expected to see a well reasoned argument for
functional programming and how entrenched the OO mentality is. What's the mess
we're in again?

~~~
dj-wonk
Complexity, the Destroyer of Simplicity. (Joe's talk is broad, perhaps
intentionally so, and hopefully will promote some big-picture thinking.)

------
zaroth
"In the middle of the pattern matching algorithm, there was this single
comment that read # and now for the tricky bit." (~10:40)

At ~28:00 is he saying that the optimal computing device could operate 27
orders of magnitude more efficiently that what we use today?

At ~36:00, finally something to make me sit up. "content addressable store".

~~~
xpe
He mentions these topics with regards to distributed hash tables:

    
    
      * https://en.wikipedia.org/wiki/Chord_(peer-to-peer)
      * https://en.wikipedia.org/wiki/Kademlia

------
rdtsc
Great talk. Very light-hearted and entertaining.

Always impressed by Joe. Programming since the 60s and still programming,
still writing, giving talks. He is a great role model. I wish I would be
programming and be just as excited about it when I am at his age.

~~~
jacquesm
I wished I would be half that excited about it at my present age!

------
dmourati
I like his speaking style and appreciate the intro to Kademlia and Chord. This
page has some visual representations: [http://tutorials.jenkov.com/p2p/peer-
routing-table.html](http://tutorials.jenkov.com/p2p/peer-routing-table.html)

------
lifeisstillgood
I am lucky enough to work in a "internal open source environment" \- I can and
do search the whole code base for a major Fortune 500 daily for pieces that
fit my needs. And I often find them - but the process of getting it refactored
to fit my exact needs (and so improving their code and the overall reduction
in entropy) is mostly impossible - because of humans No one is really willing
to change someone else's code without talking to them, agreeing, getting past
thier "yes I have tests but if you change it then I don't really know ..."

It's a fundamental problem - good well maintained tests help but this is
cultural not technical problem.

------
_prometheus
Joe and I are thinking similarly :D I'm going to dump some ideas here.

\---

# JRFC 27 - Hyper Modular Programming System

(moving it over to [https://github.com/jbenet/random-
ideas/issues/27](https://github.com/jbenet/random-ideas/issues/27))

Over the last six months I've crossed that dark threshold where the desire of
building a programming language has become an appealing idea. Terrifyingly, I
_might_ actually build this some day. Well, not a language, a programming
_system_. The arguments behind its design are long and will be written up some
day, but for now I'll just dump the central tenet and core ideas here.

## > Hyper Modularity - write symbols once

### An Illustration

You open your editor and begin to write a function. The first thing you do is
write the ([mandatory]([https://code.google.com/p/go-
wiki/wiki/CodeReviewComments#Do...](https://code.google.com/p/go-
wiki/wiki/CodeReviewComments#Doc_Comments\))) [doc
comment]([http://golang.org/doc/effective_go.html#commentary](http://golang.org/doc/effective_go.html#commentary))
describing what it does, and the type signature (yes, static typing). As you
write, [your editor
suggests]([http://npmsearch.com/?q=factorial](http://npmsearch.com/?q=factorial))
lists of functions [published to the web](npmjs.org) (public or private) that
match what you're typing. One appears promising, you inspect it. The editor
loads the code. If it is exactly what you were going to write. You select it,
and you're done.

If no result fits what you want, you continue to write the function
implementation. You decompose the problem as much as possible, each time
attempting to reuse existing functions. When done, you save it. The
editor/compiler/system parses the text, analyzes + compresses the resulting
ASG to try to find "the one way" to write the function. This representation is
then content addressed, and a module consisting of the compresses
representation, the source, and function metadata (doc string, author,
version, etc) is published to the [(permanent)
web]([http://ipfs.io/](http://ipfs.io/)), for everyone else to use.

### Important Ideas

\- exporting a symbol (functions, classes, constants, ...) is the unit of
modularity (node)

\- system centered around writing _functions_ and writing them once (node)

\- stress interfaces, decomposition, abstraction, types (haskell)

\- use doc string + function signatures to suggest already published
implementations (node, Go)

\- content address functions based on compressed representations

\- track version history of functions + dependents (in case there are bug
fixes, etc). (node)

\- if a function has a bug, can crawl the code importing it and notify
dependents of bugfix. (node, Go)

\- use static analysis to infer version numbers:
`<interface>.<implementation>` (semver inspired)

\- when importing, you always bind to a version, but can choose to bind to
`<interface>/<implementation>` or just `<interface>`

\- e.g. `factorial = import QmZGhvJiYdp9Q/QmZGhvJiYdp9Q` (though editors can
soften the ugly hashes) (node + ipfs)

\- all modules (functions) are written and published to the (permanent) web
(public or private)

\- when importing a function, you import using its content address, and bind
it to an explicit local name (`foo = import <function path>` type of thing)

\- the registry of all functions is mounted locally and accessible in the
filesystem (ipfs style)

\- _hyper modular_ means both to "very modular" and "modules are linked and on
the web"

Note: this system is not about the language, it is about the machinery and
process around producing, publishing, finding, reusing, running, testing,
maintaining, auditing, bugfixing, republishing, and understanding code. (It's
more about _the process of programming_, than _expressing programs_). This
means that the system only expresses constraints on language properties, and
might work with modified versions of existing languages.

~~~
akkartik
_" The first thing you do is write the (mandatory) doc comment describing what
it does, and the type signature. As you write, your editor suggests lists of
functions published to the web that match what you're typing."_

As a concrete example, if I say (picking a syntax at random; underscore
denotes where my cursor is):

    
    
      add :: int -> int -> int
      def add(a, b)
        """add two numbers"""
        _
    

and if the permanent web contains two functions:

    
    
      proj1_add :: int -> int -> int
      def proj1_add(a, b)
        """returns sum of arguments"""
        a+b
    
      proj2_sub :: int -> int -> int
      def proj2_sub(a, b)
        """returns difference between a and b"""
        a-b
    

Would you envision your system "matching" both or just the first? If just the
first, on what basis do you imagine figuring this out?

~~~
_prometheus
Just the first. on the strings "sum", "add", and potentially on the symbolic
operation `args[0]+args[1]`.

------
thallukrish
It is a very interesting talk. Though it might take a while for some one to
connect the dots Joe has sprayed all over.

Somewhat related to this, I have been annoyed by the way apps scatter
information and have been working to find a way of managing the mess.

[http://productionjava.blogspot.in/2014/07/the-broken-
web.htm...](http://productionjava.blogspot.in/2014/07/the-broken-web.html)

and

[http://productionjava.blogspot.in/2014/08/coding-can-be-
puni...](http://productionjava.blogspot.in/2014/08/coding-can-be-punishing-at-
timeswith.html)

------
timClicks
This talk attempts to provide a strategy for reducing complexity within
software. The whole talk is really valuable, but if you're short of time..
skip to 36:00. In a real hurry? Start at 44:17.

------
p1mrx
During the last minute of the talk, he says:

"Computers are becoming a big environmental threat. They're using more energy
than air traffic."

Is this actually true? Sure, the average person spends a lot more time on a
computer than in a plane, but still it seems crazy that they'd be comparable.
Or at least the comparison isn't very relevant, because the Internet can
significantly reduce people's need to travel.

~~~
adamnemecek
"Save the environment, code in C."

~~~
corysama
You are getting downvotes, but energy efficient computation has been a large
driver in the recent upsurge in interest in C++.

~~~
adamnemecek
Wait C++ is has been getting more popular? I'm not complaining (I mostly like
C++), I guess I just didn't get the memo.

~~~
pjmlp
Lets see.

\- Symbiam was coded in C++

\- GCC moved to C++

\- Clang and LLVM are done in C++

\- Mac OS X drivers are written in Embedded C++ subset

\- Windows team is moving the kernel code to be C++ compilable

\- JPL is moving to C++

\- AAA game studios have dropped C around PS3/XBox 360 timeframe

\- It is the only common language available in all major mobile OS SDKs

~~~
adamnemecek
I mean I was confused by the word 'recent', which to me means the last 2-3
years.

~~~
pjmlp
A few items on my list cover your 'recent'.

Decision to move Windows to C++ was announced by Herb Sutter in one of his
Microsoft talks and the Windows 8 DDK was the first to support C++ in kernel
code.

JPL going C++ was covered at their CppCon 2014 talk.

GCC switched to C++ as implementation language in 2012.

In any case, I would say, all languages with native code compilers can be used
in relation to energy efficient computation.

It is just that C and C++ are the only ones on the radar of developers (and
managers) looking for mainstream languages with native compilers.

~~~
adamnemecek
True. Facebook has also been doubling down on C++ development it seems.

~~~
pjmlp
There is a talk from Andrei Alexandrescu at Going Native 2013 where he
mentions one of Facebook KPIs is request per watt.

------
dcre
This was definitely not one of the better talks of the conference (though I
was embarrassed to say so given the way people [rightly] idolize Armstrong),
so I highly recommend checking out the rest:
[https://www.youtube.com/channel/UC_QIfHvN9auy2CoOdSfMWDw/vid...](https://www.youtube.com/channel/UC_QIfHvN9auy2CoOdSfMWDw/videos)

------
garretraziel
While I agree that his talk is a little bit "disconnected", I think that it
served its purpose when I am reading some "think big" discussion that is going
on here. While his talk doesn't have one clear topic, it does deliver huge and
interesting thoughts.

------
grondilu
I totally agree with the "abolish names and places". Why can't I just write:

    
    
        $ cp hash://<somehash> .
    

and have my computer do whatever it takes to retrieve a file with this hash
and copy it on my disk?

~~~
lomnakkus
How would you remember the hash? I guess one could have some sort of
directory-like system for mapping human-memorable names to hashes...

~~~
grondilu
> How would you remember the hash?

I wouldn't. I'd make a symbolic link.

Basically the current directory/names structure would be an abstract layer
_above_ the hash-based system.

~~~
justincormack
Plan 9 already did that in its file system...

------
serve_yay
I'm guessing this is about what a disaster it is to use software, still to
this day, but I just can't deal with his storytelling style. Takes forever to
say "OpenOffice has a shitty bug".

------
sergiotapia
What is this about?

Edit: Strange Loop is a multi-disciplinary conference that aims to bring
together the developers and thinkers building tomorrow's technology in fields
such as emerging languages, alternative databases, concurrency, distributed
systems, mobile development, and the web.

Strange Loop was created in 2009 by software developer Alex Miller and is now
run by a team of St. Louis-based friends and developers under Strange Loop
LLC, a for-profit but not particularly profitable venture.

~~~
trenchwarfare
new to coding, and volunteered for a couple shifts in exchange for entry.
first conference ever. this was AWESOME! incredibly well run, and obv not
about the $$ - but they freaking deserve all the success they get, financial
and otherwise!

------
_asciiker_
this is so true.. we already spend a lot more time fixing and tweaking code
than actually creating.

------
readerrrr
Wow this guy doesn't know what he is talking about. Just a bunch of numbers
without any arguments.

I had to stop watching when a laptop was compared to a black hole.

I'm sure the laymen are impressed though.

~~~
orbifold
I think you missed the point, that slide was about the theoretical limits of
computation, it is a very weak upper bound that won't be achieved.

