[X] kills [Y]

Humbug.  Somewhere somewhat above the pricepoint that all these boards are hitting, "community" becomes more important than the feature-list.
Otherwise Arduino would have been left in the dust a long time ago.

(Olimex in particular has lots of interesting boards, but doesn't seem to have developed much of a community for any of them. (?))

Those boot addresses look a little off

They usually will, since some sources use word addresses (datasheet) and some use byte addresses (everything associated with gcc, I think.)
A source of much  confusion :-(

Though the caveats in [the ISP Shield] Wiki doesn't bode well for my Uno.

Note that all of those caveats apply equally to any other physical mechanism for using the Uno as an ISP programmer.  They reflect limitations related to the Arduino itself rather than things specific to the shield.

You might also want to look at http://www.adafruit.com/products/462 where they pretty much use a prototype shield to build a ZIF programmer.  (note that the Arduino can not program its own cpu, so putting a ZIF socket in the current ATmega location probably doesn't do anything helpful.)

If ArduinoISP were heavily used, a REAL jumper for disabling auto-reset would probably be more useful than the switchable RESET on the ISP connector.  (Pretty soon you'd have something like the original STK500, with so many jumpers that you can hardly ever configure it correctly for anything, on the first try...)

I would change this in the .c file and leave the makefile unchanged:

Code:

/*
 * UART Baudrate, AVRStudio AVRISP only accepts 115200 bps
 */

#ifndef BAUDRATE
#define BAUDRATE 115200
#endif

Note the comment, however.  The stk500v2 protocol used sort-of specifies that it should run at 115200bps, and various programming software might not support changing the bitrate.  Turn on "verbose" uploading in the arduino preferences to confirm that avrdude is overriding the bitrate.

I'm opposed to buying a cable that I would permanently alter for a single purpose versus purchasing a more expensive revised Uno board that I could make use of for multiple purposes.

There's a saying in the open source community:  "Feel free."

By using ArduinoISP, you've put yourself among a minority of Arduino users.  Increasing the expense of the "revised Uno" to serve such a small minority would not be a good idea.

You can easily make an "ISP shield" with a programming header as you want, or even with a ZIF socket for chips.  In fact, this has been done a couple of times and you can buy one.  http://shop.evilmadscientist.com/productsmenu/tinykitlist/253 is one example.

Any chance you could take a moment to explain?

I did submit https://github.com/arduino/Arduino/issues/1337
Basically, the preprocessed file (in the build directory) gets lines like "#line 1 Blink.ino", but "blink.ino" is off in the original sketch directory, "out of scope" for the simple forms of avr-objdump.

To burn new code over either serial or I2C, you would have to have a bootloader on the target chip.
SPI is the only interface that doesn't require a bootloader.  (but if you have SPI and reset wired up, you would not need any kind of "wait" functionality on the target; via SPI the master has full control over the operation of the target.)

So except for the very first arduino, you're expecting to use the bootloader to program the boards, rather than ISP programming (you said they only have a serial connection.)  The bootloader does more than just "listen for serial data"; it's the bootloader that is responsible for reading that serial data and programming the sketch into the chip; otherwise you'd need SPI connections between the master and target...

If you want the board to self-replicate over serial, you'll have to (manually) install the bootloader on them first, using an ISP programmer.

JimboZA had it right way back in the first reply.

Take logs of both sides, take the exponent to the front, solve for exponent

See "rule 4" here: http://www.mathwords.com/l/logarithm_rules.htm

5 ^ X = 18
log(5^x) = log(18)
x * log(5) = log(18)
x = log(18)/log(5)

Or you can think:
5^x = 18
log_base5(5^x) = log_base518
x = log_base518
and then use the "change of base" forumla (rule 5 at the above page.)

Thanks.  That was the sort of detail (and actual experience) I was looking for.

The piece that I don't understand is that modern 80wire IDE cables still have 40pin connectors on each end.  So somewhere there is either "magic" to connect a bunch of the wires to GND, which might purposely connect other wires to gnd as well, OR it just leaves half the wires completely unconnected (they'd still shield things "some", maybe), in which case you really have a 40conductor cable.

I believe that the specific features you have requested:
1) provide a command-line that generates the pre-processed source.
2) fix the line number correspondence.
have both been implemented in more recent versions of the IDE.

Without code duplication, there is no problem: the code is updated with the API and everything continues to work.

There is still a problem, because someone still has to update the new code functionality.  Just because that functionality is part of the official distribution doesn't mean that it becomes effortless to maintain.   The Arduino "issue" list is long, and maintaining odd features for people outside of the arduino target audience (like makefile compatibility) is a lower priority.  For example, the line number fix introduced a bug in avr-objdump disassembly output...

I though IDE disk cables DID have 40 connections (40 pin connectors), although the more recent cables have 80 conductors. (half of the 80 conductors are GND and used for shielding, somehow "magically" connected at at least one end.)  Do the 80pin connectors have built-in connections for some of the other GND connections as well?

I was still using a mainframe with actual core memory in the early to mid 1980s.

Sounds like you were using some downlevel equipment. Bipolar memory was in full bloom in the very early 70's.

It was a DECSystem KL-10, which was introduced in 1974, originally with core memory.  The particular system I'm thinking of (Sushi.stanford.edu) was acquired well after DEC announced the discontinuation of the PDP10s, and it's quite possible that the core memory unit (which was a 3rd party external box, rather than internal memory) was a "bargain" because of it's "obsolete" status.  It was an "interesting" time where PDP10 lovers could pick up hardware for prices comparable to the transportation costs plus the first year power bill...

this type of memory lasted until the bipolar transistor replaced it.

longer than that.  Transistor memory takes about 6 transistors per cell, so a core memory cell was significantly smaller than transistor memory until after the widespread availability of integrated circuits (and specifically, the Intel 1103 1k DRAM, IIRC.)  http://en.wikipedia.org/wiki/Magnetic-core_memory
I was still using a mainframe with actual core memory in the early to mid 1980s.