All I Know³
Information, transmission, modulation, and noise – 3rd Edition

My Life As A Programmer – The Early Years

My Forty Years With Computers

Spring (2005) was the 40th anniversary of my first real job.

(This is republished from some blog entries at blogs.sun.com/rchrd. I wanted to preserve these notes, since that blog is now dormant.)

In June, 1965, I started my first full-time job as a computer programmer. I was 21, with a B.S. in Math from Brooklyn Poly. Oddly enough, when I graduated Poly in ’64, I had no idea what I was going to do. I was not a great student, and knew right off I’d never make a great mathematician. And I didn’t play poker, a sign that my career in math would be limited. But along the way as an undergrad I had part-time jobs in the Brooklyn Poly computer center (IBM 650/7044)and learned Fortran and assembly language programming. I even got a teaching fellowship after graduation, the first the Poly computer center ever issued. I taught a course on programming, while at the same time taking Max Goldstein and Jack Schwartz’s Principles of Computation course across the river at the NYU Courant Institute.

This turned out to be a fortunate thing. Because after finishing Max’s course in the Spring of ’65 (I got an A with a term project simulating a Turing machine using a macro language for the IBM 7044), I informally asked Max for a job at NYU. Max was director of the Courant Institute computer center, then run by the Atomic Energy Commission. And I knew they were about to replace their IBM 7094 systems with a “supercomputer” – the CDC 6600.
To my amazement, Max mentioned that someone had just left the group and there was an opening. A few days later I had a job application in the mail and by June an office on the third floor of the new Warren Weaver hall on Mercer Street.

This was probably the most exciting moment in my life. The Courant Institute was world-famous in mathematics. And Richard Courant (a student of the great David Hilbert) was there, up on the 12th floor. I met Courant many times in the elevator. He wore sneakers but was always nattily dressed in suit and tie. There were many other famous middle-European ex-pats at the Institute, and I joined them every afternoon at 3 for tea in the lounge on the 13th floor.

I was 21 and in the company of some of the greatest minds in applied math.

So I moved myself from a tiny flat in Brooklyn Heights to a tiny flat on Waverly Place in the Village. It was 1965, I was 21 years old. and living in the Village!

My job at the computer center turned out to be maintaining the Fortran compiler and the Chippewa Operating System (COS) on Serial #4 6600. At the time, this was the fastest/biggest computer available. It cost $14 million. Your laptop is more powerful by orders of magnitude. So much as happened in those 40 years.

[Sidenote: What I really wanted to be was a recording engineer. I had a number of contacts and worked with some composers involved in electronic music during that period (e.g. Morton Subotnick). I felt much more creative in the world of music than math, but I knew that if I were to quit my job at NYU I would be drafted instantly. Vietnam was on everyone's mind. A job at NYU carried with it an occupational deferment.]

There were only a handful of 6600 installations around the world. NCAR in Boulder, Lawrence Livermore Labs, and CERN near Geneva. I worked directly with the CDC compiler developer, Garner McCrossen, in Chippewa Falls, Wisconsin. I would report bugs to him by mail (there was no email!), and I’d get back a set of punched cards which would patch the binary compiler code to fix the problems. Every so often I’d get an updated compiler in the mail. It would be a number of boxes of punched cards. These cards were actually punched in BINARY (not ASCII text). Eventually he would start sending tapes. I got pretty good as a diagnostician. I became an accomplished assembly language programmer for the 6600. I also helped create the user support department at the computer center, where we would help other programmers fix bugs and improve the performance of their programs. It was all very exciting.

By 1968 I had had enough with living in New York City. Things had turned really bad. Where I really wanted to go was to Berkeley. They had recently installed a 6600 at the Lawrence Berkeley Lab computer center, also run by the AEC (eventually the Dept. of Energy), and I was in communication with their systems programmers discussing bugs and fixes. In March of ’68 I sent out two letters asking for jobs. One was to the LBL Computer Center, the other to the University of London Computer Center, where they had also just installed a 6600. I never heard from London. Berkeley offered me a job. So in June of 1968, the day Robert Kennedy was shot in L.A., I was on a plane to Berkeley, to take a job as systems programmer at the LBL Computer Center. I stayed at LBL for 14 years.

The funny thing is that I always wanted to go to UC Berkeley. But I couldn’t get in as an undergrad. I also applied as for grad school, but wasn’t admitted. Now here they were hiring me as a professional programmer. How ironic!

So while staring up at the ceiling from my bed during the flu, I started thinking about the Spring in 1965 at my first real job at NYU/Courant Institute.

First thing that came to mind is how much I owed Max Goldstein thanks for giving me a job at NYU that spring. Its true that I had completed 2 semesters of his course Principles of Computing, which I took at NYU because Brooklyn Poly offered no graduate level courses in computing at that time. I guess I was smart enough to make my presence known to Max in the class, and actually it was a wonderful course… an overview of computing in 1965. So when I came around to asking him about a job, he already knew me.

But who would give a professional level programming job at a leading computing center to a 21-year-old long-haired kid with barely a B.S.? I doubt if I were in his position today (and oddly enough, he was 45 in 1965… I’m 15 years older now than he was then, or something like that) I would have given that kid a chance.

I do remember pouring myself into mastering the programming skills I needed to be effective.
The CDC 6600 was a radical design. Actually, it was 13 virtual

computers in a box. 12 “peripheral processors” fed data in and out of the main
CPU, which itself was a 60-bit multi-processing compute engine. Learning all the
programming tricks was done mainly be reading the code others had written. There
was a very minimalist manual (I still have a copy), and any documentation was
hard to come by. So I started writing documentation for the users at NYU. I
didn’t know it then, but that was the start of my career as a technical writer
(the job I now have at Sun Microsystems).

You have to remember that back then there was no email, no internet, and no
display screens or interactive terminals. Everything was done on punched cards.
Programs were written with pen and paper, following detailed flow charts (if you
were so inclined). There were professional keypunchers available, but I
preferred to punch my own, which gave me a chance to revise and correct the code
as I was writing it.

Also there were only two (or three) programming languages available. One was
Fortran, the other assembly language for the CPU, and another assembly language
for the peripheral processors (PP’s).

My mind was so deep into the operating system and compilers that at night I
would dream about being caught up in the web of PPs swirling around me, the CPU.
Of course, I wasn’t sleeping much… spending all my time in the computer room.
And I lived 2 blocks away. It was very intense.

But eventually my other interests crowded in. I heard (somehow) that people in
the NYU music department were interested in running a computer music program at
the center that was being developed at Bell Labs. It was called Music IV, and
simulated sound generation modules numerically. It generated a digital tape
analogous to the 2 channel output of a synthesizer. I got involved with some of
the music department people and helped them make a bid to the AEC to lend time
to the music department for this. But the AEC said no, and that was the end of it.
In the meantime I got to meet Milton Babbit, Ben Boretz, Vladimir Ussachevsky, and, eventually,
Morton Subotnick who had just arrived from San Francisco to start the NYU

“Intermedia Center”. Mort opened the NYU electronic music studio on Bleecker
Street, above the Bleecker St Cinema, a building owned by NYU and used as art
studios. He brought with him an early analog synthesizer system built for him
by Don Buchla (of Berkeley, California) . I was intrigued. The music department folks said I
should take a look at Mort’s system and see if we could create a program at NYU
to do all the synthesis digitally. I met with Mort, and before I knew it I
became his assistant.

So during the day I worked as a systems programmer on the world’s fastest
computer, and in the evening I was working with the world’s first real time
music synthesizer, and with a master composer for the instrument. I helped Mort
put his first album together,
Silver Apples of the Moon. I even suggested the title, from a Yeats poem, The Song of Wandering Angus.

I completely gave up on the idea of programming digitally what already was working in Buchla’s voltage controlled devices.

With the digital process the sound events had to be meticulously programmed in

a simulation language, the program run, which could take many hours for a few
minutes of sound, and then the digital tape converted to a few minutes of
actual sound. Very tedious and expensive process. With Don’s voltage controlled
equipment, the result was immediate. Just connect up the units and start.

——–

The story so far: It’s 1965 and I’m at the
Courant Institute (NYU) Computer Center.

So that’s where I found myself forty years ago, at the age of 21 with my first
real job as a programmer. Eventually, my assignment was to keep the FORTRAN
compiler and libraries, assembler, and associated “products” up and
running. Others maintained the operating system. Back then CDC was having a
lot of trouble releasing its much touted SIPROS operating system. But Serial
#4 6600 was already installed and powered up at the Institute’s new building
on Mercer Street in the Village. CDC engineers were running an operating system
called COS (Chippewa OS, because the 6600 was designed and built at Seymour
Cray’s own lab in Chippewa Falls, Wisconsin.) COS was intended just as a test
system for site engineers. There was very little documentation (a single spiral
bound xeroxed collection of strange notes and diagrams — I still have one).
At one point, Max Goldstein, the Center’s director, gave up waiting for SIPROS
and asked the systems group (me and three others) to get COS running as a production
system. Trial by fire!

It was a bare-bones OS. For example, we had two high-speed line printers (those
form-fed 136 column monsters), but the OS only could handle one printer at
a time. My first job was to learn enough assembler to rewrite the printer driver
to handle two print streams and two printers. (Parallel programming!) We had
an early version of a two-printer driver, but it didn’t really work very well
… it put alternate print lines on alternate printers! But somehow I did manage
to pull it off and within a few weeks we had both printers running.

What I do remember the most about that period was system time!

If you lived thru the period of large computer
mainframe system installations like the 6600, you will remember system
time
. That was when the computer would be unloaded of all jobs and turned
over to the systems group to test new versions of the OS without doing damage
to the job stream.

It was usually at 2am. For a number of days I got the whole machine
room for myself to test out new versions of the print driver. And I’d be in there all alone. The OS was written in assembly language for the 12-bit 6600 peripheral
processor (PP) and then key-punched into cards and compiled into a binary program,
which was then punched onto cards. The 6600 had a 60-bit CPU and 10 of these
PPUs. All the lower I/O operations, like reading the disk and functioning the
printer, were done by PPU programs.

Eventually I was able to get both printers printing complete separate
output jobs. But the next operator wasn’t going to arrive until 6am. And I
was the only person there. So if I finished at 3 there was nothing else to
do but turn
the whole system off and go home!
Now, turning off a $14 Million
computer system is not something you take lightly. The CDC engineers had printed
up a set of instructions on how to go around the room turning peripherals off
in the proper sequence. And then, how to turn off the main unit. I remember
pausing at the switch, heart pounding, going thru in my mind all the steps
and checking them off… was everything ready? And then opening the safety
release and pushing the switch.

What would happen next was really scary. You suddenly realized how much background
noise there was, and how you had learned to ignore it. Because soon all the
fans and pumps (water cooled) would start shutting off, and then you could
hear the massive disks (eight 5′ diameter platters arranged in a cabinet mounted vertically)
would start spinning down with an high loud whirrr slowly lowering
in pitch. It took many minutes for the disk to completely spin down. And then,
this room that was so full of sound was now … deathly …
quiet. My neck would be in a cold sweat. I’d gather up my stuff, click off
the lights, and get the hell out of there as fast as I could.

That was system time.

———-

Courant Institute NYU Computer Center – Sometime around 1967

So for some reason I gravitated over to working on what we called then “programming
systems”, as opposed to “operating systems”. And by programming systems we
meant the compiler (there was only one, Fortran), the assembler, the linker,
and the run-time libraries. By now I was a very proficient Fortran IV programmer,
and a very good assembly language programmer for the CDC 6600. At this early
stage in the life of the CDC 6000 series, we had to use prototype assemblers
and compilers designed mainly for the support engineers and not for software
development. Eventually CDC produced a real macro assembler, COMPASS. You can
find some interesting details about the early days of the CDC 6600 in Julian
Blake’s article about the 6600 at CERN
from about this very same time,
1966-67.

You also have to realize that this was some 15 years before UNIX became the
standard operating systems on all computers. In 1967 every computer company
produced their own incompatible operating system. Some looked a lot like IBMs,
but others, like CDCs were quite different. For one thing, the whole world
of computing was batch. Interactive computing was yet to come. So a
program run consisted of a deck of punched cards. The first set of cards in
the deck were Job Control Cards, followed by a specially punched card (the
bottom three rows punched in the first column) denoting “end-of-record” followed
by program cards in Fortran source, followed by another end-of-record, and
then data cards to be read by the program in execution. The last card in the
deck would be another specially punched card with the bottom four rows of the
first column punched to indicate “end-of-file”.

The first Control Card was the Job card, specifying the account number to
use to charge resources agains, the priority of the job, the time limit, and
the memory limit. (Hang on, I’m doing this from memory.) The cards
that followed gave commands in “Job Control Language” that were read by the
system when the job entered the input queue. The Fortran compiler was invoked
by a very simple command:    RUN.

So the Chippewa OS 6600 Fortran compiler was called “RUN”. And it was written
by Garner McCrossen at the CDC Chippewa Falls Lab. Garner was one of the original
team that worked with Seymour Cray to design the hardware and software of the
6600.

RUN was a remarkable piece of code, all written in an early assembly language
for the 6600. And it was the first compiler I had ever seen. I studied it day
and night. There was no internal documentation and few comments. And my job
was to maintain the compiler, find and report bugs back to Garner, and to receive
and install updates from him. I never completely understood how it worked,
but I did finally figure out how its working parts were organized. Still, it
was a great mystery, my Rosetta Stone.

This proved to be a lot of fun. So a physicist would come into my office complaining
that his program was doing something strange. We would stare at the code intensely,
drinking cup after cup of coffee, drawing diagrams, and analyzing every bit
of the physicist’s Fortran code. Maybe he made some silly mistake, like passing
a floating point value to a subprogram that defined the argument to be integer.
Or, if that wasn’t it, adding strategic statements to print computed values
around the suspect code to catch where it started to go off. Sometimes we
would discover that the compiler did something wrong, and generated the wrong
code. We’d find a way around the problem to get the physicist’s code to work,
and then I’d isolate the problem in a test case that would always fail. I’d
mail all this back to Garner (remember: no internet yet, no email, not even
faxes… real dark ages). In a week or so I’d get a package in return. If it
was a box it was a completely new binary version of the RUN compiler, punched
on cards. If it was a thin envelope it was an octal patch, just a couple
of cards.

Ah, the octal patch! What a great invention! Nothing like it today.

First, why octal? Well, the 6600 was a 60-bit machine. 64-bit machines
and 8-bit bytes were still a few years away. Seymour Cray designed the 6600
around octal arithmetic. A 60-bit word was 20 octal digits. (One octal digit
is 3 binary bits, or 0 thru 7). Octal arithmetic is actually very easy to learn.
And it’s much easier than hexadecimal, based on the 8-bit byte, which has digits
0-7,A,B,C,D,E,F. Try adding 1EF to E0A. In octal, that would be 757 + 7012
= 7771 in octal. Anyway, everything in memory was expressed in octal.

The octal patch was a set of cards punched in octal that contained an address
section and a data section. If you put these cards after a binary deck and
invoked the right command (which now I’ve forgotten) , the binary deck would
be loaded into memory, the contents of the data overwritten at the specified
patch addresses by the patch data words, and a new binary deck punched. That’s
how you would update a binary program! Typically, the patch would insert a
jump to high memory at some point where the binary code needed to be corrected.
New code would be entered at that high memory address, and that code would
then jump back to the original address+1, taking the program on a little detour.

Once I had a very strange bug and I called Garner in Wisconsin. Over the phone
he dictated a binary patch by reading his assembled compiler code and making
the fix on the fly. Only this time instead of punching cards, I made the changes
directly at the computer console into the binary file sitting in the system!

And it worked!

It was not unusual to receive a moldy, smelly box in the mail containing a
wheel of Wisconsin Cheddar from Garner for helping him debug RUN. All that
fun, and cheese too!

——–

 

Courant Institute

In 1968, after 3 years as a CDC 6600 systems programmer, it came time for
this staunch New Yorker to leave the Courant
Institute NYU Computer Center
on Mercer Street in Greenwich Village, and move West to Berkeley.

The late 60′s in NYC were dreadful. And it got much worse thru
70′s when the City almost went bankrupt. I started working at NYU when I was
21, and left for Berkeley a much older 24.

Actually, I always wanted to go to Berkeley. I had applied there for undergrad,
and didn’t get in (I would have been in the class of ’64). I also applied for
graduate school, and didn’t get in. But in 1968, after realizing that they
had the same CDC6600 as NYU, I applied for a job in the LRL computer center
(it was called the Lawrence Radiation Lab then), and got it!

Interestingly, what made me finally write that resume, put it in an envelope,
find a stamp, and put it in the mail was a minor event in the life of a New
Yorker, but it was the camel that broke the straw’s back, so to speak.

I was living in Washington Square Village, an apartment complex just south
of Washington Square Park and NYU. In fact, from my eighth floor studio apartment
I could look into the window of my 3rd floor office at Courant.
(In the mornings I could peer out my window with my binoculars to see if there
were any yellow phone messages on my desk! This was before answering machines
and voice mail.)

One fine early Spring morning I left my apartment to get a capuccino before
starting the day at the computer center. But outside the building, on the sidewalk
blocking the way, was a large mound of dirty clothes someone had left overnight.
People were walking around and stepping over it because it seemed to be in
the way. As I got closer I realized there was a person in that pile of dirty
and stinky pile. With a dirty grey beard, wearing two hats and newspapers stuffed
into shoes without laces. His face, the part you could see, was grey, very
grey, almost green. His mouth was dry and open slightly. The guy was dead.
No doubt about it. And people were walking around him, annoyed, getting on
with their own business.

That was it for me. I went straight up to my office, dragged out the typewriter
and started writing my resume and the process to get out of there.

Interestingly, I typed up TWO resumes, and envelopes, and sent them on their
way. One was to Berkeley. The other was to the University of London Computer
Center, where they also had a CDC 6600. I had met some of the programmers from
ULCC at a user’s group meeting a while back. My very first foreign trip was
in 1966 to Dublin and London, by myself. I fell in love with London, if that’s
at all possible. So going back was an intriguing idea.

Never heard from London. (But that story doesn’t end there, as you will find
out in a later installment. Stay tuned.)

But Berkeley did write back almost immediately. They wanted to talk
to me. I sent another resume to Control Data’s software division, which was
in Sunnyvale, CA, just south of San Francisco in what was yet-to-be-called
Silicon Valley. In a few weeks I had arranged an interview at CDC and had them
fly me out there. I arranged interviews at LRL as well, basically on CDC’s
dime. So in late April, 1968, I found myself interviewing at CDC and Berkeley.
I had bought my first real suit (at a small downtown NYC store called Barney’s)
for the occasion. Clearly, I didn’t need it. The interviews went well. Berkeley
was beautiful, one of those sunny spring days after a night of light rain.
Everything was in bloom.

Within a few weeks a got an offer from Berkeley, and a lesser offer from CDC.
I accepted the Berkeley offer immediately and started packing. I was absolutely
excited! (If I recall correctly, my starting salary was somewhere around $6
or $9K. How things have changed! One could live quite well in 1968 in Berkeley
for under $10K/year.)

So after bringing 52 boxes of books and stuff, all my posessions, to a shipping
agent, I was on a plane to San Francisco and a new life as a Californian. The
date was June 5,1968 . On the plane the pilot announced that Robert Kennedy
had been killed in L.A.
And I began wishing that I’d heard from London instead.

———————–

So where am I in this story now? Let’s see… 1968, June 5, and I’m flying into San Francisco Airport with 60 boxes of books and everything I own, to take a job at the University of California Lawrence Radiation Lab (now Lawrence Berkeley Lab) computer center.  

I started working at the LRL Computer Center, up on the hills above the Berkeley campus in July, 1968. I stayed there 13 years. And for most of that time I was responsible for maintaining the compiler (FORTRAN), assembler (COMPASS), linker/loader, I/O libraries, and related stuff. I also served as user support and wrote a lot of the user documentation.

By ’68, CDC had given up on its futuristic SIPROS operating system and was forced to adopt the system developed by the engineers in Chippewa Falls (Wisconsin) under Seymour Cray. It was known simply as COS and was a productized version of the raw system we started using at NYU in ’65. Still, input into the system was cards, output on paper or tape or punched cards. It would be another 5 years before display terminals appeared.

The picture above was taken in 1971 (by my Dad on a visit from NY, which may explain the sunglasses.) But note the typewriter. I was the only one on the staff with a typewriter, on which I wrote articles for the center newsletter and printed (xeroxed) documentation. Note also the bound listings on the desk and shelf. The shelf has the listing of the CDC 6600 assembler, COMPASS, and the RUN compiler.

What you can’t see is the card file to my left. It held trays of cards. But by ’71 source code management had progressed from decks of cards to source files on tapes and a program called UPDATE from CDC. UPDATE was an ancestor of SCCS on Unix. Now the update instructions (“replace card 248 in deck XYZ with the following cards”) were punched on cards and fed into the card reader with the job control cards that read the source tape and generated a new version of the source program. This is how we maintained the thousands of lines of the compiler, assembler, etc.

What I enjoyed the most of my years at LBL was the community of scientists, engineers, mathematicians, and programmers. You never knew who you would meet in the cafeteria, including Nobel prize winners. The systems group was quite small, maybe 5 full-time programmers (one of them is also now at Sun, Marty Itzkowitz , and ironically just like at LBL, his office in Menlo Park is still next to mine).

In March of 1971, I and a small team of programmers and computer operators went to Chippewa Falls to run acceptance tests on the CDC 7600 that was installed at LBL later in the year. The 7600 was a big improvement on the 6600, running 4 times faster at 27.5 nanoseconds, and featured multiple pipelined functional units, which meant that you didn’t have to wait for one multipy to end before you started another.

Also, by this time CDC had developed its SCOPE operating system, based on limited time sharing and remote job entry (satellite card reader and printer stations linked over phone lines). But after careful review, the LBL systems group decided to further develop the COS system for its own needs, and called the derived operating system BKY. And my job was to keep the compilers and tools that CDC made available under SCOPE running under BKY.

One great advance was CDC’s FTN compiler, which replaced RUN. FTN did some amazing scalar optimizations. It knew a lot about instruction timing and scheduling. Finally we had a compiler that would produce code that ran as fast or faster than equivalent code written by hand in assembler. But maintaining FTN was a lot different than maintaining RUN. It was no longer possible to call up the compiler programmer and report a problem, and then get a patch in the mail in a few days. Things had gotten very corporate. Filing a bug against FTN required filling out a form, include test source code and listings, and mailing it to CDC Sunnyvale. Eventually a distribution tape with a new compiler would be issued with a list of fixed bugs. Hopefully, your bug would be on that list. For me the interesting part was creating a software environment in which the compilers and tools could live that interfaced the BKY system. Altho at the programming level BKY and SCOPE were not that far apart, there were always problems as SCOPE got more mature. And, keep in mind that all systems programming on these systems was done in assembly language.

 



Leave a Reply

« Phil Ochs Movie
Other Minds 16! »

About:


Richard Friedman lives in Oakland, CA, is a freelance tech writer/editor, web designer, photographer, is a Director of Other Minds, wrote his first computer program in 1962 for the IBM 650. It played dice. He is also a ham radio (AG6RF) operator, and he also takes a lot of photographs, composes music, and does a weekly radio program on KALW called Music From Other Minds.
He is not Kinky.

View Richard Friedman's profile on LinkedIn

Photo


all I've seen :: photo blog
New images added


More Photo Galleries/Portfolios

Music

Music From Other Minds
Friday nights at 11pm, on KALW 91.7 FM San Francisco. More...

categories:

search blog:

archives:

Links

RCHRD@SUN My blog about computers, computer history, programming, and work.

HOME
rchrd.com
Amateur Radio - AG6RF
Other Websites Worth Visiting:
Other Minds New Music
Internet Archive Entire Internet, Archived
New Music Box American Music Center
UBU WEB A Treasure of Recorded Sound, Music/Poetry!
BoingBoing A Directory of Wonderful Things

Music Blogs Worth Reading:
Kyle Gann's "PostClassic"
Miguel Frasconi, composer/performer
Overgrown Path
Sequenza 21 Forum
Alex Ross: The Rest Is Noise

Photo Blogs Worth Viewing:
SFMike's CIVIC CENTER
mooncruise* Photo Magazine
FILE Photo Magazine
Nassio: NYC, etc
Wanderlustagraphy
Street 9:NYC

Uncategorizable Yet Notable:
14to42.net: NYC Steet Signs
Lichtensteiger: Cagean Website
Ben Katchor: Picture Stories

Internet Radio Stations:
Pandora.com
Concertzender NL
RadiOM OtherMinds Archives
Kyle Gann's Postclassic
Robin Cox's Iridian Radio

other:

What Is This?

I started All I Know in June 2004 using Pivot, and
All I Know² Second Edition, in September 2006 using Movable Type.
This is All I Know³ Third Edition, started in March 2008 using WordPress. Read more.


Subscribe to this blog's RSS feed. My favorite feed reader?

Archives

Archives of all the entries in the First and Second Edition are located on the old archives page


A project of Other Minds, radiOM.org makes globally available rare and underexposed content documenting the history of new and experimental music.

Creative Commons License
This weblog is licensed under a Creative Commons License.

On Pandora.com

My Pandora.com profile

meta:

Contact Me

Just make a comment and write PRIVATE at the top. I'll read it, but I won't publish it.
rchrd - Flickriver

[powered by WordPress.]

42 queries. 1.058 seconds

Search Site

Custom Search