
OOP Before OOP with Simula - bibyte
https://twobithistory.org/2019/01/31/simula.html
======
thomasfl
It’s worth boring that OOP was invented by Lisp programmers. Simula was the
first language were you could write class. At the University of Oslo in
Norway, most computer science courses used Simula up until the late 1990’s.
Some of the lectures was held by the inventors of OOP themeselves.

~~~
seanmcdirmid
Well, there was also first language to do prototype OO (sketchpad) back in
1962. Also the first VPL and probably constraint based programming language as
well.

------
k__
Doesn't surprise me. If I look how people build class systems with JS before
ES2015, I'd guess all languages that have closures and higher order functions
could invent OOP. Maybe that isn't even needed IDK.

~~~
jrimbault
People did it in C way back, with usually structs containing their value and a
table of functions associated with them (vtable). You can do "inheritance" by
having the parent struct be the first member of the child struct. You can do
all sorts of fun stuff (composition is easy of course, injection also). The
only thing of note, is that you can't "curry" the source, you'll always have
to give the "source/this/self" object as an argument to the method. This isn't
any different from how you could in python, for example, do : `"my
string".split(" ")` or `str.split("my string", " ")`.

(just some fun little experiments I did last year
[https://github.com/jRimbault/DataStructures/blob/master/lib/...](https://github.com/jRimbault/DataStructures/blob/master/lib/struct/String.h),
there isn't any vtable, but it does show a string "class/struct" with all
private fields, and methods for creating, managing those objects)

~~~
marmaduke
> You can do "inheritance" by having the parent struct be the first member of
> the child struct. You can do all sorts of fun stuff

I have done this, 'fun' is not how I describe the result to colleagues

~~~
jrimbault
Alright, -fun +nightmarish. Still fun though.

------
tyingq
I like Perl's approach to OOP. Almost 100% of it is a single function,
bless(). Everything else is just namespaces, which isn't specifically an OO
thing. There's no magic "this" or "self", so the OO is very easy to
understand.

~~~
nocman
Um, perhaps I'm misunderstanding your point, but Perl 5's object model was
based on that of Python.

And _every_ method of a Perl 5 object receives a $self scalar as its first
argument ( see
[https://perldoc.perl.org/perlobj.html](https://perldoc.perl.org/perlobj.html)
).

In fact, Larry Wall specifically stated in the 11th "State of the Onion"
speech that he "stole" Python's object system for Perl 5.

I remembered him saying this, so I went to find the transcript. However, I
could not find a transcript of the actual speech. I did, though, find this
perlmonks.org quote of Larry Wall (from that speech):

"I don't really know much about Python. I only stole its object system for
Perl 5. I have since repented."

[https://www.perlmonks.org/?node_id=1212836](https://www.perlmonks.org/?node_id=1212836)

So unless you mean Perl 5's "$self" is somehow "non-magic" (whatever you mean
by that), I guess I don't understand what you mean when you say it has no
"this" or "self".

~~~
tyingq
It doesn't have $this or $self. It has @_, which predates the OO that went
into Perl.

~~~
nocman
Sorry, just getting back to this.

Yeah, it has @_, and in the Perl object model, the first entry in the @_ array
is a reference to the object, which is almost always called $self.

Anyway, what people name the reference doesn't matter. The point is that it
functions like 'this' and 'self' do in other languages, and it is very much
required in object methods (which differ from normal subs in that they are
passed that first argument automatically).

------
foobar_
Whoever talks about OOP without mentioning simula should never be hired.

