Hacker News Reader

> On two occasions I have been asked,—“Pray, Mr. Babbage, if you put into the machine wrong figures, will the right answers come out?” In one case a member of the Upper, and in the other a member of the Lower, House put this question. I am not able rightly to apprehend the kind of confusion of ideas that could provoke such a question.

It's nice to know, as someone that works with computers, that this layman attitude is eternal and not something unique to our current times.

Although, I always wondered if that was a snide way of asking if the machine was a fake, that Babbage didn't pick up on.

I was going to say that Poe's law existed even back then, but apparently it was coined by a different Poe in 2005.

Machinery tends to be used to "refine" raw materials. Rough timber is transformed into precisely dimensioned planks, for example. So it's not unreasonable to ask whether a machine for producing numerical data can operate with crude and inaccurate raw materials (inputs).

Consider: The "regula falsi" approach to solving equations in one unknown actually involves a guessed, "false" input. https://en.m.wikipedia.org/wiki/Regula_falsi#The_regula_fals...

Robert Recorde wrote:

  Gesse at this woorke as happe doth leade.
  By chaunce to truthe you may procede.
  And firste woorke by the question,
  Although no truthe therein be don.
  Suche falsehode is so good a grounde,
  That truth by it will soone be founde.
  From many bate to many mo,
  From to fewe take to fewe also.
  With to much ioyne to fewe againe,
  To to fewe adde to manye plaine.
  In crossewaies multiplye contrary kinde,
  All truthe by falsehode for to fynde.

Now, somebody on HN ("wzdd") has previously tried to defend Babbage, on more than one occasion (e.g. https://news.ycombinator.com/item?id=29605135), saying that he wasn't mystified by the misunderstanding, but instead was making some kind of joke at his own expense (not a snide comment at the expense of the questioner.) I'm far from convinced.

It seems to me that we shouldn't be celebrating this mean-spirited passage from Babbage's writing.

I always assumed we are only hearing Babbage's side without the context of the question. Was this part of a series of questions presented to Babbage trying to help him along in almost a Socratic method to understand the Parliament's hesitation? Knowing that most politicians of that era discussed 'to whose benefit' and 'for what purpose' when most of the upper class were landed gentry, it would be most likely affecting a whole new sector of the economy they didn't understand. How would this machine be used for Law? Could it help the homeless? War widows? Managing pensions?

I presume the question could also be directed at whether the machine would require a specially trained operator and thus more funding or whether anyone skilled in the Arts and the Trades could work the machine efficiently without oversight or much necessary direction. Given the machine was a whole new step and direction of the economy, I can understand their hesitation.

A computer without a program, while brilliant, is useless.

WRT the digit count, the piece Babbage missed, IMO, was that he could continue his overall scheme of using automation to 'inflate' a polynomial to a more generic time/space efficiency tradeoff. He needed all of that precision, but that wasn't required in his mill (the analytical engine's ALU), because you can chain ops with carries like we do today. In fact some of the first electronic computers we used (which fit in a similar niche, calculating polynomials to generate tables, generally for WWII artillery) literally had single digit ALUs in order to get the cost under control enough to be viable. Their results had greater than single digit precision.

People already had tables of logarithms with lower precision. At the time he did a survey of what tables were available in the world, and it turned out the French had just produced some quite impressive tables, using a lot of manual labor. His value proposition to the British Government was that he can deliver something even better at a fraction of the manual labor (basically only a few people to turn on the crank). The Brits were enamored with the concept of automation at the time, and he made a proof of concept machine with lower precision that he was very happy to demonstrate wherever he would go. Why did he aim for 40 digits? Maybe he did some back of the envelope estimation for the error propagation. If you start with an average error of 10^(-40), then after n additions, in the worst case you can have an error of n*10^(-40). Which is not so bad. But the problem is that in the difference engine you end up adding intermediate results to intermediate results, many, many times over. So if you only look at the worst possible results, you end up needing a lot of precision to start with. Of course, nowadays we know better how to analyze the propagation of errors, but in his time he either didn't know how, or he couldn't convince other people that he can get the total error under control if he used a lower precision throughout. In any case, he completely underestimated the difficulty of scaling the project from his toy example to the full blown final machine.

They had tables, but they were rife with errors. Some accidental, some intentional as a form of copy protection. Britain didn't respect French copyright at the time, so as soon as they put their hands on a book it would have been fine to copy. Therefore his proposition was for accuracy from mechanical nature of what he was proposing.

And everything you said doesn't discount using a lower precision ALU, and chaining the results with carry propagation. We do that today; every Diffie-Hellman your computer performs involves numbers far larger than it's ALU width. And bit serial machines have a long history.

The Difference Engine was doing only additions and subtractions. For additions and subtractions, it does not make sense to split the operands in smaller pieces and then chain the results by carry propagation. Or rather it does make sense, but this is exactly how they are implemented to begin with: the operands are split in groups of 1 digit each, and then the operation is done digit by digit, and there's carry from one digit to the next.

The Difference Engine does not do any multiplications.

As for the stupendous precision. I implemented a difference engine today in Excel to see what's going on. It's a very fun exercise, one can do it in 15 min. But be warned, you'll waste hours playing with the thing.

Here's how the Difference Engine works. You want to calculate a function f at the points 0,dx, 2dx, 3dx, etc. You do it inductively, using the formula

f(x + dx) = f(x) + f'(x)dx

But who is going to give you f'(x)? Well, you calculate that inductively too. Or more precisely (this is crucial) you calculate the whole f'(x)dx inductively:

f'(x + dx) dx = f'(x) dx + f''(x) dx^2

And then for f'' dx^2, you say

f''(x + dx) dx^2 = f''(x) dx^2 + f'''(x) dx^3

At some point you decide to stop, so you assume that a certain derivative is constant. That's the order of the scheme. Wikipedia states that the second Difference Engine envisioned by Babbage had an order of 7 and 31 digits of precision, but I suspect it's a mistake. I think it's more likely the order of 8. The 8'th derivative of log(x) evaluated at 1 is -7!=-5040. If you use a dx=0.0001 then you need to store the number 504010^-32 = 504 10^31.

So, I suspect Babbage was trying to produce log tables with increments of 0.0001 with a precision of six digits. If you look at the error of this scheme, you'll see that it grows exponentially, and after just 1000 steps the error is of the order of 10^-6. So you need to reset your starting point, and start again. You produce 1000 more logs, then you reset again. After a while, the scheme becomes better behaved (fundamentally because you move further away from the function's singularity, which is zero). By the time you are around 4, you can run 10000 steps while keeping the error below 10^-6.

Now, it looks like a successor of Babbage, Scheutz, actually built a difference engine. I think the guy deserves as much admiration, if not more, than Babbage himself. He used 15 digits and only 4th order differences. But if you look at engines with different orders, you'll find out that higher orders stop giving a significant bang for the buck after the 4th order.

Does 15 digits/4th order make sense? Well, only if you are quite smart, but I think Scheutz was plenty: the fourth order derivative of log at 1 is 3!=6, so you need to be able to store the number 60.0001^4=610^-16. But how do you do that if you only have 15 digits? Well very simple: you observe that for the first about 1000 steps, all the numbers in the table start with 0.0, so you don't store only the digits after that, and for that you only need 15 digits.

> BTW his blog post "Babbage was a true genius" looks great: http://tomforsyth1000.github.io/blog.wiki.html#%5B%5BBabbage...

Highlighting this for extra exposure. For even more info, plus an emulator, see [1] (also linked from the blog post).

[1] https://www.fourmilab.ch/babbage/cards.html

> Pray, Mr. Babbage, if you put into the machine wrong figures, will the right answers come out

Of course the tricky answer is, where possible that is exactly what we should strive for.

People hate it when their SQL Server responds to a 60 line procedure with "Syntax error" even though I'm sure that's technically correct - while they like it when the Rust compiler spits out an explanation of why what they wrote can't work, pointing at the specific places it's wrong and suggesting what might help.

If you ask Google for "tow the line" it suggests "Did you mean toe the line?" because sure enough that's the expression you probably wanted (unless what you wanted was specifically people explaining why it isn't "tow the line" but don't worry it does link those explanations)

Back in his day that was still not technically possible, and maybe not even in demand at the time(Even today "real programmers" brag about not needing such things).

Seems like detecting errors like Rust wouldn't occur to someone in a world where basically no "smart objects" of any kind exist. Up until recently, most objects were passive tools under direct human control with no more intelligence than a punch card loom at the most.

Lots of people still don't really think much outside of the "Manmade things as passive tools" mindset or see a need for anything more.

John Nagle (Animats) has commented a few times about how, contrary to the "high culture" story of the evolution of computers (Turing, von Neumann etc), the gradual evolution of "calculators" was itself leading up to computers

That's a great point, and I've been thinking about the similar issue with compilers and type systems. Nowadays people seem to frame type systems as originating from math and logic, but really the first type systems were for instruction selection -- generating different code for a+b when they're ints or floats. It was more of an engineering thing.

So many rules in C support that, and most of them survive in C++ (arrays decay to pointers, etc.)

In Search of Types is a great read: https://www.cs.tufts.edu/~nr/cs257/archive/stephen-kell/in-s...

The last 40 years have seen an impressive confluence of theory and practice in programming language design, with the interesting side-effect of taking the sense of “types” originating in symbolic logic and implanting it into engineering traditions.

I kinda want to read about type systems from a historically accurate perspective. I think it's well known that Ritchie and Thompson didn't agree with many of the type safety improvements in ANSI C (even though ANSI C seems ridiculously weak from a modern perspective).

Somewhat related to this is that there seems to be a ton of exposition on Hindley Milner type systems, but very little on explicit object oriented type systems (Java, C#, C++, Kotlin, Swift, etc.)

> “Pray, Mr. Babbage, if you put into the machine wrong figures, will the right answers come out?” In one case a member of the Upper, and in the other a member of the Lower, House put this question. I am not able rightly to apprehend the kind of confusion of ideas that could provoke such a question.

This was the most memorable quote from his autobiography for me!

GIGO - Garbage In Garbage Out - was the first think taught to me in school in Computer Class.

I always used to think why they taught us that - it's common sense! Turns out people have been asking this question since the conception of programmable computers!

And yet, Google tries to show the right links to wrong search requests.

*edit: To me, this seems to be the greatest obstacle towards artificial intelligence. We search AI within computational concepts, where GIGO holds, whereas society already knows what intelligence is. It could be more fruitful to start from there compared to training NNs until they speak.

> • John Nagle (Animats) has commented a few times about how, contrary to the "high culture" story of the evolution of computers (Turing, von Neumann etc), the gradual evolution of "calculators" was itself leading up to computers (e.g. https://news.ycombinator.com/item?id=10636154). Something similar appears to have happened with Babbage, where he started with a simple calculating device and, thinking about it more deeply, single-handedly came up with a Turing-complete design and was writing programs for it.

Konrad Zuse was a civil engineer who was annoyed by doing manual numerical calculations and so started to build his computers (22-bit floating point machines). He too saw how many engineer-man-centuries these machines could save and approached the Nazi government which of course blundered that and thought computers were irrelevant.

> He too saw how many engineer-man-centuries these machines could save and approached the Nazi government which of course blundered that and thought computers were irrelevant.

Zuse built "computers" and process control for military R&D and production. He wasn't a major concern or priority at a high level, but given resources "thought irrelevant" projects wouldn't have gotten.

> the Nazi government which of course blundered that and thought computers were irrelevant.

Well, it seems they were enthusiastic users of IBM machines, maintenance service, spare parts, training etc.

https://en.wikipedia.org/wiki/IBM_and_the_Holocaust

Up-voted you because of the high quality comment. Thank you for the provided links.

Bit confused by Δ⁷uₓ = 0, should it be read as “approximately equals”?

Either that, or I think the idea is that uₓ is a polynomial of degree at most 6. (Such a polynomial is what the difference engine computes, and it may be a good approximation for the actually desired function.)

Floating point is basically just scientific notation. Which means that in theory, it even might have been invented back then.