
The Connection Machine (1985) [pdf] - ingve
https://dspace.mit.edu/bitstream/handle/1721.1/14719/18524280-MIT.pdf
======
lispm
While we are at it:

Connection Machine CM-2 Technical Summary (PDF)

[http://people.csail.mit.edu/bradley/cm5docs/nov06/Connection...](http://people.csail.mit.edu/bradley/cm5docs/nov06/ConnectionMachineModelCM-2TechnicalSummary.pdf)

The Essential StarLisp Manual, with Programming Examples for the Connection
Machine (PDF)

[https://omohundro.files.wordpress.com/2009/03/omohundro86_th...](https://omohundro.files.wordpress.com/2009/03/omohundro86_the_essential_starlisp_manual.pdf)

Getting Started in StarLisp (PDF)

[http://people.csail.mit.edu/bradley/cm5docs/nov06/GettingSta...](http://people.csail.mit.edu/bradley/cm5docs/nov06/GettingStartedinStarLisp.pdf)

~~~
protomyth
Was there ever a port of StarLisp to other platforms?

~~~
kgwgk
There is a simulator (implemented in in Common Lisp) available at
[http://www.softwarepreservation.org/projects/LISP/starlisp/s...](http://www.softwarepreservation.org/projects/LISP/starlisp/sim/)
(and a few other documents at
[http://www.softwarepreservation.org/projects/LISP/starlisp](http://www.softwarepreservation.org/projects/LISP/starlisp)
)

------
corysama
I've long enjoyed the story of Richard Feynman's time spent working on the
Connection Machine.

[http://longnow.org/essays/richard-feynman-connection-
machine...](http://longnow.org/essays/richard-feynman-connection-machine/)

~~~
srtjstjsj
That article, from 1989, talks about building a neural network, which is, 30
years later, finally owning the mainstream of applied computer science

------
nickpsecurity
It's important to look at this in context of history. A lot of what came about
today started under the Strategic Computing Initiative (link below). It was a
massive investment over a period of time that threw money at every smart
person or neat idea you could think of hoping for scientific equivalent of
moonshots. We got a bunch of them, too, so it worked imho. Thinking Machines
explored the novel concept of massively parallel CPU's with languages & work
distribution modified for them. Supercomputers of time had fewer, less-radical
cores. Projects like Thinking Machines led to Massively-Parallel Processing
architectures that combined hundreds to thousands of more-typical CPU's,
custom interconnects, and special tools for programming. My favorite of those
were Distributed, Shared-Memory (DSM) machines. Later, Beowulf clusters were
invested to use commodity CPU's, boards, and networking to bring cost down.
High-performance interconnects improved and got cheaper simultaneously. These
trends led to commodity clusters from startups and semi-custom clusters from
IBM (esp SP2), Cray, SGI, etc.

The reason for doing something so different & risky like Thinking Machines
Corp is to try to create those ripple effects. Well, build and dominate a
market is number 1 but government funders trying to get ahead wanted ripples
as a backup. They got it, too. Also, the machine could pull off amazing stuff
[1] with its architecture. Similar one's using 8-bitters piled into a chip
were used for neural networks. One could probably re-created benefits of
Thinking Machines same way for the problems that suited it.

[1] [http://kk.org/mt-files/outofcontrol/ch15-d.html](http://kk.org/mt-
files/outofcontrol/ch15-d.html)

[https://monoskop.org/images/d/d4/Roland_Alex_Shiman_Philip_S...](https://monoskop.org/images/d/d4/Roland_Alex_Shiman_Philip_Strategic_Computing_DARPA_and_the_Quest_for_Machine_Intelligence_1983-1993.pdf)

Note: The book is well-worth skimming through given how it documents how
modern computing practices formed. I had never heard of SCI. I thought the
stuff was unrelated but turns out it was all connected. Documents lots of
attempts, justifications, policy effects, etc. Gold mine.

~~~
ontouchstart
Thanks for sharing the link. Fascinating stories.

Lessons form the history
[https://twitter.com/ontouchstart/status/764790460900581376](https://twitter.com/ontouchstart/status/764790460900581376)

------
spitfire
This (along with the Burroughs B5000 architecture) are my favourite computers
of all time. I have the book form of his thesis on my shelf right next to
Knuth and Kenya Hara.

I feel like junior people should be given a tour of the greatest hits from the
past when they start in industry.[1]

1\. So they can judiciously steal the good ideas later on in their careers.

~~~
pjmlp
Fully agree it appears millenals somehow think history of computing starts
with a PDP-11.

It is really sad the state of culture transfer in our industry.

~~~
bitwize
PDP-11? Try the 1984 Macintosh.

~~~
gaius
Hah! They think that JavaScript without a framework is "bare metal"...

~~~
chris_st
I'll just leave this here:

[https://twitter.com/jimmycuadra/status/329759546283266048](https://twitter.com/jimmycuadra/status/329759546283266048)

------
api
These kinds of efforts were always doomed by Moore's law. Why build them if
you can wait 5 years and then build something of equivalent power with
commodity hardware?

If Moore's law really is ending I could see that changing.

~~~
mechagodzilla
I think the Anton machines for simulating molecular dynamics
([https://en.wikipedia.org/wiki/Anton_(computer)](https://en.wikipedia.org/wiki/Anton_\(computer\)))
show that this _has_ already changed. The 8 year old Anton 1 machines are
still ~1-2 orders of magnitude faster than commodity clusters, and the now 3
year old Anton 2 is another order of magnitude faster still.

~~~
stcredzero
The way an ALU or CUDA core gets its data to operate on and where that data
goes and the latency involved are the big deal for large computational tasks
now. Specialized ASICs also can give a huge advantage. With specialization,
you can eliminate overhead. People keep talking about reconfigurable arrays of
hardware as well.

------
jgelsey
Very well written thesis. The machine, however, was extraordinarily difficult
to program, resulting in Thinking Machine's quick death once they actually
tried to compete commercially with Convex and Cray.

~~~
convolvatron
It wasn't really an open market since the US Gov was the only customer. They
liked to spread money around to keep some kind of competition going. There
were a lot of fans of the CM architecture. It did take substantial work to get
a code running, but once you did the price performance scaling and stability
was pretty nice. Enough people had gone through that process that there were
plenty of codes that would have like to have continued running.

The generally accepted narrative is that TMC upper management really screwed
up. More tactically the CM-5 really stumbled, with a host of hardware, system
software, compiler and environment problems. Right before they folded it was
starting to be a really nice platform to use. But very expensive, and the 2-3
years from the CM-2 to that point were quite dark.

If you look at the Cray machines from the last 5-10 years they are pretty
similar to the CM-5 \- fat tree-like guaranteed delivery message network with
credits \- commodity processors and the primary node type \- attached vector
processors \- front end nodes running commodity OS

of course there are lots of subtle differences, but if you squint...of course
the language environments aren't the same (except of course for parallel
fortran :/)

~~~
jgelsey
Nope, USG was only ~1/3 the market for supercomputing back then. There were
lots of industrial uses for supercomputing (e.g. computational fluid dynamics
calculations to design tires that hydroplaned less, flame dynamics to create
more efficient engines, finite element analysis to model parasitic effects in
semiconductors, ..) However the market for the TMC was indeed almost
exclusively the USG (or research departments at a few large corporations, and
a few universities) because no one could figure out how to program it for
something useful - as mentioned before, it was really, really hard to program
anything more than a really constrained scenario on the CM.

------
scentoni
The Computer History Museum in Mountain View has a beautiful CM-1 on display:
[http://www.computerhistory.org/revolution/supercomputers/10/...](http://www.computerhistory.org/revolution/supercomputers/10/73/285)

~~~
effie
Thanks, that looks just as cool as the old Cray. People really cared much more
about design back then.

------
lispm
The Connection Machine had some cool art and animation usage.

Karl Sims developed an art installation using algorithms to evolve images
based on user selections. It was to see for example in Paris at the Centre
Pompidou.

As you can see on his page, the installation used a bunch of color graphics
screens, a Connection Machine (2^15 processors). You can see the machine on
the top image on the right. The actual software was written in Starlisp:

[http://www.karlsims.com/genetic-images.html](http://www.karlsims.com/genetic-
images.html)

Karl Sims gives a demo: [https://vimeo.com/7723361](https://vimeo.com/7723361)

Karl also studied particle systems using a CM-2:

[https://archive.org/details/sims_particle_dreams_1988](https://archive.org/details/sims_particle_dreams_1988)

Plants:
[https://archive.org/details/sims_panspermia_1990](https://archive.org/details/sims_panspermia_1990)

~~~
juliendorra
I got to interact with the Pompidou installation, mid 90s, you could select
your favorite rendering via a foot switch (one for each screen) and the
Connection Machine would then render a new set of image based / derived from
your choice. It was presented as images created by a "genetic algorithm".

Having a super computer in an art museum was a really powerful statement. (But
I was probably more impressed by the whole thing that by the resulting
generated images)

It was a brief period at Pompidou when they would, regularly, present computer
based works, at the frontier between art and science. (The series was called
"revue virtuelle", virtual review)

------
ryao
Every time I hear about these, I think about the Jurassic Park movie, which
claimed to run the park using a network of Thinking Machines Corporation CM-5
machines instead of a Cray supercomputer that the book had used.

~~~
qubex
That was the Connection Machine 5, a very different (MIMD/fat tree)
architecture compared to the ‘classic’ Connection Machine 2-type architecture
(SIMD/hypercube) described in this thesis.

~~~
qubex
Anybody feel like explaining why I've been down voted for making what is (to
the best of my knowledge) a factual statement?

~~~
douche
They're just internet points, nothing to get too worked up over.

On mobile it can be really easy to accidentally downvote, too.

~~~
sangnoir
> On mobile it can be really easy to accidentally downvote, too.

Good thing it is now possible to undo an accidental downvotes (or upvotes)

------
getpost
In 1995, Gary Taubes (lately a writer on health and diet) wrote a profile of
Thinking Machines Corp.

The Rise and Fall of Thinking Machines A close up look at a doomed-yet-
brilliant start-up computer company that never quite grasped the basics of
business.

[http://www.inc.com/magazine/19950915/2622.html](http://www.inc.com/magazine/19950915/2622.html)

~~~
gdubs
Funny -- been reading Taubes's "Why we get fat" which is super interesting.
Read this article a while back and really enjoyed it. Taubes is a great
writer.

------
convolvatron
this work was pretty thoroughly examined and realized by the resulting
company, Thinking Machines.

the one part of the story thatI always wanted to hear about is why CM Lisp
turned out to be an ineffective language. The 'thinner'*Lisp was usable for a
surprisingly large number of things, but CM Lisp was alot more forward looking
and interesting.

------
jkestner
Generally applicable takeaway:

"But the things that we studied were so new that no one else knew exactly what
they were doing either. It was amateurs who made the progress."

"In retrospect, if we had had any understanding of how complicated the project
was going to be, we never would have started."

That's the universal truth of anything great I've done.

------
peter303
The 1980s were the era of clever supercomputing architechures. You had the
onset of computed aided design of CPUs or boards; an individual, or small
group, could design an d build a supercomputer. PC or Workstation CPU chips
were not yet powerful enough to dethrone mainframes or supercomputers. I was
science grad student at Stanford that time. On a monthly basis it seemed some
new supercomputer company would try to sell us their clever new machine in the
million dollar range: supercomputing for the price of a departmental computer.

But these super companies could only update their architectures every 3-5
years, whereas Intel was chugging out faster CPU every year or six months. It
only took a decaded for a commodity cluster to beat a mini supercomter company
in price-performance. Most these companies never made it to 3.0.

------
stcredzero
I used to hang out in school with someone who wrote assembly language on one
of the Connection Machines. He told me once that there was a single assembly
command for sorting 65536 items or something like that. (Probably MergeSort
using the tree stucture.)

I never get to finish my stories about this guy.

------
ScottBurson
I never thought SIMD machines would be useful for AI. I've now been proved
wrong, but it took 30 years.

~~~
jgelsey
Well, much of "AI" in its modern form is statistical analysis. SIMD machines
are great for linear algebra (integrated vector/scalar machines like 70's CDC
machines, Cray and Convex through the 90's, most Intel and AMD processors
today through their SSE and AVX instruction set extensions). Any statistical
calculations that use linear algebra can be accelerated with a SIMD
architecture.

~~~
eggy
True, and as hardware keeps evolving towards array-based setups like
GPUs/ASICS with FPGAs and other hybrids, languages like J/APL/K fit them like
a glove.

Using qdb from Kx or Jd for J, both columnar databases with billion row
operations on capable vector-processing hardware is the modern realization of
this type of computing.

These languages are not currently too popular, but I think a cousin of theirs
will come on the scene and really light things up. Some current attempts at
newer GPGPU targeted languages have popped up these past few years [1, 2, 3,
4].

The difference between these array languages and something like NumPy and
other libs to add array processing and better numerics, is that the columnar
databases or stores, have the array language built-in; you can abstract out,
but if you program with them, there are no onion layers between you and speed
and processing.

[1] [https://github.com/melsman/apltail/](https://github.com/melsman/apltail/)

[2] [http://futhark-lang.org/index.html](http://futhark-lang.org/index.html)

[3] PDF -
[http://www.elsman.com/pdf/array14_final.pdf](http://www.elsman.com/pdf/array14_final.pdf)

[4] PDF - [http://futhark-lang.org/publications/fhpc16.pdf](http://futhark-
lang.org/publications/fhpc16.pdf)

------
srtjstjsj
How does the Connection Machine compare to a modern GPU?

~~~
chris_st
Well, they're both SIMD architectures. But I think the way you program them
is/was very different.

I quite miss programming the CM-2 in C* -- it was a really nice environment,
and really pretty easy to program to (contrary to the legend I've seen thrown
about that they were hard to program). Once you understood the various library
functions, it was usually pretty straightforward to get things done.

