Oracle FAQ Your Portal to the Oracle Knowledge Grid

Home -> Community -> Usenet -> comp.databases.theory -> Re: Simula (Was: The wisdom of the object mentors)

Re: Simula (Was: The wisdom of the object mentors)

From: Robert Martin <>
Date: Wed, 21 Jun 2006 17:43:22 -0500
Message-ID: <2006062117432250878-unclebob@objectmentorcom>

On 2006-06-21 09:23:48 -0500, "S Perryman" <> said:

> "Robert Martin" <> wrote in message
> news:2006062012555670933-unclebob_at_objectmentorcom...

>> I didn't say anything about WHEN Simula had objects. I was talking bout >> the the way the idea was formulated.

> So you are talking about *the way they formulated the idea of objects* ??


> From Jan Holmevik, "Compiling Simula" :
Interesting, but I'm not sure I understand the relevance.
> 1. Here is your *own* text :
> "They talked about how they
> stumbled upon
> ^^^^^^^^ ^^^^
> the notion of objects ..."
> As the text you have quoted says nothing of the kind (marked ^^^ ) ,
> retract the claim.

What would you like me to say? They thought long, deep, and hard, and then decided to move the stack frame to the heap? fine. Maybe they thought long, deep, and hard and deduced that the stack frame should move to the heap.

Or maybe the looked at that damned stack frame and said to themselves, "I've got all my state arranged in these local variables, and I've got all these local functions to manipulate them, I wish I could block the creating function and let other functions use the block -- oh wait!, We just have to move it to the heap!"

I don't know which way it went, and I don't really care. What the text in "Structured Programming" seems to make abundantly clear is that Dahl, at least, thought about the transition from Algol to Simula, in terms of the movement of the stack frame to the heap.

> 2. Here is what Nygaard and Dahl say about storage allocation. From the
> Development of the Simula Languages - 1978, page 250 :
> "2.3.2 Storage Allocation.
> The initial plan was that the simulation facility
> should be implemented as a procedure package
> and a simple preprocessor on top of ALGOL 60.
> One idea that looked promising at the time came
> from the observation that ALGOL, by its recursive
> block mechanism, did cater for multiple
> occurrences of user defined data structures
> rather like the "customers" that would go from
> one "station ~' to the next in our simulation
> models.

So all we have to do is move the stack frame to the heap!

> Also the station descriptions had block format.
> It turned out, however, that the block
> structure of ALGOL was not very helpful, in
> fact the preprocessor would have to fight
> against it by breaking up the blocks, making
> local variables non-local, etc. There was no
> hope of integrating special purpose operations
> like "hold (time interval)" completely into
> the language, since it implied a kind of "parallel"
> processing foreign to ALGOL and conflicting with
> ALGOL's strict dynamic stack regime of procedure
> calls and storage allocation.

Damn, can't block the calling function and let others use the block. Let's move it to the heap!

> During the spring of 1963 we became more a .~ more
> convinced that the project was on a wrong track,
> and started toying with

  ^^^^^^^^^^^^^^^^^^^^^^^ <--- "stumbled upon"

> the idea of making
> nontrivial changes to ALGOL by breaking with the
> stack regime.

And moving it to the heap.

> But I do see that a concept of objects was first published by the
> Simula creators at least one year before the earliest time that you can
> possibly claim (the time at which they changed their storage allocation
> scheme) .

A paper that has some very vague references to data structures in a queue is not nearly as compelling a parallel with objects as Dahl's description of moving the block to the heap. The goals of the initial paper could have been achieved without anything like objects.

Indeed, look back on the first paragraph of section 2.3.2. They use the word "Observation" not the word "Deduction". The observed that the blocks of Algol behaved in a way that had some similarities to the data structures in their simulation paper; but ALGOL wasn't perfect. The stack structure got in the way. So they moved the blocks from the stack to the heap. In other words, they stumbled on a good idea.

> And the reason for the heap storage structure for Simula was a
> carefully considered development, and not something discovered by
> accident.

I don't draw that conclusion from what you quoted, and I don't see how you can either. They clearly say that they were toying with ideas and making observations of the coincidence of blocks and customers. The stumbling nature of the discovery seems quite plain
> For years you have tried to suggest that the NCC were just a bunch of
> programmers hacking around with Algol, and that Simula and what is now
> OOP came from stumbling by accident upon something akin to the
> 'pencillin dish' discovery.

There is nothing shameful about serendipity. Good serendipity takes a lot of hard work. I have no doubt that Dahl and Nygaard are/were very intelligent and thoughtful people who deserve a lot of credit. But like all men who make great discoveries, I think they experienced a bit of luck.

> The reality, as told by the creators themselves, people
> who were involved with Simula (Ron Kerr etc) , and those
> who diligently researched the Simula projects (Jan
> Holmevik etc) , tells a different story.

It didn't sound different to me. It sounded like some guys with a problem to solve who toyed with some ideas and made some interesting observations, and stumbled into something good.

> The game is over : cease and desist with the Simula
> mis-information.

No, I think I'll hold to my "stumbled upon" thesis. Your argument was less than convincing.

Robert C. Martin (Uncle Bob)  | email:
Object Mentor Inc.            | blog:
The Agile Transition Experts  | web:
800-338-6716                  |
Received on Wed Jun 21 2006 - 17:43:22 CDT

Original text of this message