(2016)
NeXT used 'Display Postscript' a display server that was basically a inferior copy of Sun's NeWS system. This was later changed because NeXT was to small and Adobe didn't want to support Display Postscript anymore. Sun of course killed NeWS because they wanted to be a 'standard'. Next didn't care about standards. They had less applications then CDE Unix, and far lower deployment in the 90s.
Objective C is one of many language that you could use to build UI libraries on top of some display system. Objective C wasn't the best or inherently better then many others. Objective C adoption by Next was kind of a historical accident based on office location.
Having something VM based for UI development isn't actually that much of an issue, when the hardware manufacture delivers the OS with the VM included. And usually it his the hardware manufacture that delivers the OS. And VM bases system can be integrated well with the core OS, object oriented or not. And that VM are inherently to slow is also questionable, specially for UI apps that can use C libraries and the Display Server for the most performance relevant stuff.
Apple itself had a very nice system for UI development on Dylan that was arguable better in many way then the Next system. But when Steve Jobs came and they had Next, that wasn't developed anymore.
What Jobs showed of in the late 90s wasn't exactly revolutionary stuff. But Jobs always presents everything as revolutionary.
IPhone development in 2010 working the same as Next development in 1990 is a sign of 'failure', not of success.
- Oral History of Blaine Garst [PDF]: https://archive.computerhistory.org/resources/access/text/20...
- Oral History of Blaine Garst [Video]: https://www.youtube.com/watch?v=qtEIq7fe_KQ
- Oral History of Steve Naroff [PDF]: https://archive.computerhistory.org/resources/access/text/20...
- Oral History of Steve Naroff [Video]: https://www.youtube.com/watch?v=ljx0Zh7eidE
Some notable applications done in it:
- Altsys Virtuoso --- this became Macromedia Freehand
- Lotus Improv --- cloned to become Quantrix Financial Modeler
- Doom notably was developed on NeXTstep and the WAD/level editor was never ported (though alternatives were later developed)
- Glenn Reid's PasteUp and TouchType --- two of the nicest apps for working with documents and type I ever had occasion to use
and a number of ports were done quite quickly and were arguably the best ever versions --- WordPerfect for NeXTstep was done in six weeks and FrameMaker on the NeXT stands out for an interface which I missed when using it on Mac or Windows.
In particular, I'd really like to have a successor to/replacement for Touchtype.app (and if that could be grown into a replacement for Macromedia Freehand, that would be great) --- what tool would allow developing this easily, and making press-ready files which perfectly match what is seen on-screen?
Side note... I feel similarly about the Java to Kotlin transition. Sooo much better. Although, I don't hate Java NEARLY as much as Obj-C.
Virtual memory was a huge issue for UI development with a retained-mode system like DPS; thrashing window contents is very not fun if you want a responsive UI. Apple spent years optimizing VM for this purpose after the NeXT purchase.
As a side note, Apple Dylan seems incredibly limiting and opinionated for no reason. I find it interesting the website lamenting its death only shows screenshots [2][3][4] of the "advanced" editor, rather than any successful applications made using Dylan.
Also, how can I incrementally migrate Dylan into existing codebases, which were most likely C, at the time? Does it have an FFI? Also, most software engineers mental models at the time were imperative, and they expected them to learn the intricacies of functional programming and object-oriented at the same time?
That's not even to mention the logistics about running it:
> Keeping your source code in a fully version-tracked, object-oriented database with full metadata is an idea whose time has long since arrived, yet most of us still spend our time editing text files. Apple Dylan could export and import code from text files, but once you’ve used an IDE that takes advantage of fine-grained object storage of your source, you’ll never want to go back. [5]
Does this mean I'd need to shape my entire source control system around Apple Dylan? How would diffs and collaboration work? To use my source control system would I have to "export" it to plaintext every time? Text-based AppKit and Obj-C fit right into existing source control systems of the day.
Also Obj-C and AppKit was already dogfooded heavily within NeXT. The system UI was built using it, as well as all the apps that shipped with the system. You can't say that about Dylan and MacOS 9.
[1] https://opendylan.org/history/apple-dylan/screenshots/misc.h...
[2] https://opendylan.org/history/apple-dylan/screenshots/browse...
[3] https://opendylan.org/history/apple-dylan/screenshots/dynami...
[4] https://opendylan.org/history/apple-dylan/screenshots/index....
It is magical the way I can just use the C libraries with all the dynamic goodness Obj-C.
https://www.youtube.com/watch?v=UGhfB-NICzg
A sun vs next rapid development challenge.
Also, you're 100% right. The square brackets are what immediately repulsed me and continued to befuddle me even after years of experience with it. Also, everything just feels "backwards" to me if that makes any sense. Coming from Java/C#/JavaScript everything just seemed unintuitive to me at all times. Also, I think this was heavily compounded by using xCode which (at the time) was incredibly laggy. So, I'd mess up the Obj-C syntax and the IDE wouldn't tell me for what felt like forever. Often I'd make a change and hit "play" before the syntax highlighting caught up and that always felt infuriating.
I last used xCode about 4 years ago and it was still an issue then (even with swift).
Because it is. Obj-C comes from the Smalltalk lineage by way of Alan Kay, using message passing [0] versus method invocation. It's a subtle difference with huge implications to how you design systems. Method invocation won out mostly because of Java and C++, but there was a time it wasn't clear which was the better OO paradigm.
What other choice did NeXT have?
C++ was invented about the time NeXT started. Microsoft didn't even release MFC until 1992.
C...yikes.
Pascal. Would Steve had went along with that?
Not listed here, but also available, is the oral history of Brad Cox and the later Objective-C paper authored by Naroff, Cox, Hsu (the author of the linked blog post) for HOPL IV. Someone else will have to dig up the links.
You can also find interviews by other NeXTSteppers on the CHM site like Avi Tevanian and others. I think the Naroff one is best.
I think that one of the tragedies of older programming languages is that they survive long enough for people to forget the technical - and technological - constraints that influenced their design. Swift is great, but there are reasons why there weren't any Swift-like languages being developed in or around 1984.
Similar feelings about Java. It is definitely not my favorite programming language. (I suppose Kotlin isn't either, but it's in the top n.) But it's hard for me to actually hate it. Java walked so that Kotlin could run.
For collaborative projects on the other hand, it can become a handful to maintain if everybody contributing isn't staying on top of hygiene with null checks, type checks, etc. Swift helps to keep all of that under control.
I've observed some folks have a visceral reaction to having to use Xcode, I don't really understand it myself. I can understand being annoyed at having to use a specific IDE to write iOS and Mac apps, e.g., it's harder to bring your own text editor like you usually can, it's going to make your life a lot harder if you try to to avoid using Xcode. But comparing Xcode to any IDEs like the JetBrains IDEs I've used (mainly the discontinued AppCode), Android Studio (also JetBrains under the hood), or other similarly complex development environments like Unreal or Unity, I don't see any of these as a clear winner. Personally I'd prefer using Xcode to any of those. I suspect this comes down to just whether you like native Mac apps or not, Xcode is a native Mac app and if you like that aesthetic than you'll like Xcode. I suspect most of the dislike for Xcode is really just folks who dislike the Mac platform (e.g., the UI toolkit) overall.
It's really kind of a bummer that we don't have well-known examples of "skinnable" programming languages already. The closest we get are the ones that let you choose your set of keywords for different locales in case you don't want to work with an English-based PL and those block based languages that let you manipulate them as blocks or edit the textual form. I firmly believe that PL skinning would really benefit so many otherwise worthwhile languages that get short-shrift because of negative reactions to the surface-level details. I'm referring in particular languages like those in the Pascal family. (You could also conceive of e.g. a skin for Golang that doesn't have leading caps be the determiner for whether a function is public or not. There are lots of applications for this, and the variations are a non-issue when you have an ecosystem with strong norms about applying a code formatter (like gofmt), which can dictate the format of the canonical on-disk representation.)
Quote from "How To Become a Hacker" by Eric S. Raymond: http://www.catb.org/esr/faqs/hacker-howto.html
[1] https://www.labouseur.com/courses/erlang/history-of-erlang-a....
There were two teams fighting for delivering the OS, one using Dylan, other using C++, eventually the C++ team won the internal politics, even though the Dylan one was relatively ahead.
Newton was programmed in NewtonScript, prototype based OOP.
Eventually the SDK allowed for C++ native extensions, and on the later version of the OS, before Newton was killed, there was already a basic JIT in place.
Additionally, as someone that ported a visualisation framework from NeXTSTEP to Windows, the Acorn would never be able to run NeXTSTEP.
NeXTSTEP was ridiculously expensive for a reason, in terms of hardware capabilities for the time.
No other language comes close to this incredible source-level interop. Here be dragons, but there's also lots of opportunity (and fun, from a programming languace theory perspective).
Maybe one it they will rewrite the Objective-C, who knows.
Kotlin transition is a Google thing, outside Android barely anyone notices that it exists.
https://cs.gmu.edu/~sean/stuff/java-objc.html
Even Java EE was actually a rebooted Objective-C based project done internally at Sun during the OpenSTEP days, aka Distributed Objects Everywhere.
https://blog.metaobject.com/2019/12/the-4-stages-of-objectiv...
Its first two stages are just that, but it has moved beyond, for good reasons.
Even the Object Pascal to C++ transition at Apple was mostly caused by increased UNIX adoption, and Apple programmers wanting to offer similar experiences, thus MPW was born.
Same on other platforms, until C and C++ eventually won everywhere, at least until several new kids decided to challenge them in various fronts.
One that you seldom see nowadays, outside games, is pure GUI frameworks using C or C++.
"In contrast to the traditional technique of calling a program by name, message passing uses an object model to distinguish the general function from the specific implementations. The invoking program sends a message and relies on the object to select and execute the appropriate code."
Method invocation won out mostly because of Java and C++
but according to the wikipedia article java uses message passing.
supposedly the distinction is that i can have a generic method that gets called if a named method can not be found. in smalltalk that's doesNotUnderstand: in ruby it's method_missing. javascript used to have __noSuchMethod__, in php i can overload __call, in pike i do the same with defining a method called `(), and many more.
so are they all using message passing? and then if java is supposed to use message passing and javascript removed __noSuchMethod__ it seems that alone can't be the distinction.
if there is a distinction at all then it look more like an implementation detail that does not actually affect what kind of code you can write, and more importantly, based on that it is not at all clear that method invocation won out.
I feel like so much awesome engineering in XNU around security and portability, as well as innovations like IOKit are swept under the rug because "it's just FreeBSD."
I still think it's a shame that more people don't take advantage of the Mach side of XNU more. Launchd and Mach ports are a powerful combination IMO.
Also, you can change the destination of a message send at runtime, but you can't change the destination of a function call unless you're dtrace and can do code patching.
and the profound enlightenment ( https://news.ycombinator.com/item?id=42130432 ) is not specific to message passing but about a dynamic language runtime. being able to intercept messages/function calls is just one of the benefits of that.
He isn’t famous for being a programmer, but he could do it, and he certainly understood it.
Bona fide message passing is asynchronous. A message is sent and the send operation immediately returns, without blocking for a reply.
Nothing else should be called "message passing".
Kotlin hardly does more than 10% of JVM workloads, and it isn't as if any JVM vendor is replacing Java with Kotlin on their JVM implementation.
Besides Google with ART, which is anyway not a JVM proper, not fully TCK compliant to start with.
And Jobs kept most of the money ($4,750), gave Woz $350 and went off to India to achieve enlightenment.
NextStep had seen more development and existed earlier and was used more, that much is clear.
I am not saying they made the wrong discussion sticking with it at Post-Jobs Apple.
My broader point was just that the article leaves out a lot of other stuff happening at the same time.
There were many alternatives.
Pascal is language family. Xerox did Pascal like Cedar at around the same time. Thing Modula-2 existed. Next could have done something along those lines. I'm sure there were commercial versions of that kind of stuff floating around.
Smalltalk was a big family at the time. Lisp OO system were already common. There were lots of commercial version of that they could have licensed.
Sun with NeWS had a very extended PostScript that basically allowed you to write most of the application in it.
There was a lot of stuff going on back then already. History always hides how much stuff was actually happening. Sadly most of it isn't open source, so tons of great stuff goes into a historical blackhole.
My point is, with the amount of money Next was able to raise and invest in these systems, they could have gone a number of different ways. They made a reasonable discussion at the time.
To be honest, as someone who was into SGI computers as a kid, accepting the reality I would NEVER be able to own one, I hoped one day I would get to use or try one in the workplace. Of course, by then, technology had moved and these expensive machines are now affordable, simple a Windows PC with a good graphics card!
Getting back to NeXT, I heard "Next" thrown about when reading up on ID Software (Doom, Quake, etc) but never really appreciated what this was until later on. When I finally spent the time to understand that this "Next" was a computer, I started to appreciate how cool it was especially back in 1990! It made me appreciate how far ahead they were with programming/development tools. I mean.. Visual Studio finally caught up with productivity.. like.. 10 years later!
It is great to see the history of NeXT continue -- not just being "merged" into Apple but with OpenSTEP and others.
It also makes me appreciate less known programming languages that, one day, could become "mainstream" at any point. Hardly anyone knew much about Objective-C but became a popular tool for Apple developers with OSX. Thats why I always have a grin when people mock a less known language because "hardly anyone uses it" or "hardly anyone knows about it" -- that could change, you know.
Graphical/integrated .tex editing environments are a frequently encountered application type, and there seems to be at least one for pretty much every programming environment --- I'm not aware of a graphical which has feature parity with TeXview.app and which is similarly consistent with its interface (it did win an Apple Design Award back in the day) --- if that's the case, then how can it be that developing with InterfaceBuilder and Objective-C and the NS-objects was so bad? If that's not the case, what development platform would you like to put forward which should have an even better TeX environment?
I don't see why he couldn't have. It's a far more elegant language and it and other Wirth languages like Oberon have inspired several current programming languages. The standard programming language of the Lisa and Mac was Pascal, and Apple even added object oriented features to it as Clascal (earlier than Wirth's Oberon and not compatible with it).
So, the gist of the difference is this: object-oriented programming is, at its core, about late binding. Specifically, delaying decisions about what code will run when until run-time. But there's still some wiggle room to decide how late certain decisions are made. Most mainstream object-oriented languages like Java and C# more-or-less wait until the start of run-time to decide, but at that point the mapping from argument type to which code is run is pretty much settled. (This isn't necessarily 100% true, but it's the general rule.)
In a system that uses message passing, it's pushed even later, to method invocation time. Basically, each object (actor, whatever) gets to decide what code will be executed to handle a message every time it receives a new message, even for messages of the same type. In practice, most the time it's always the same code. But the point is that this level of dynamicism is a first-class language feature and not just a thing you can accomplish with hacks.
[1] https://www.mikeash.com/pyblog/objc_msgsends-new-prototype.h...
These platforms had no development tools. The firmware and software runtimes were created outside. I would guess that there definitely C was involved for much of the firmware and that an on device Dylan runtime had C and assembler code.
The interface builder was written in Dylan and running inside the Dylan runtime.
The early use of Dylan (actually its precursor language Ralph) was to develop software on a Mac for an external device, like tablets and handheld computers. The development system was an external mainboard attached to a Mac. Apple released eventually a first device with ARM 610 20Mhz CPU, 640Kb RAM and 4MB ROM as a product. A few of the early internal development environments were written in Lisp on the Mac, using a lot of memory (precious and expensive megabytes!).
> Apple Dylan environment
That was a prototype of the Apple Dylan environment, later released as a technical preview. It was also never a product. Apple at that time often developed software prototypes and the released product was then recoded as a more efficient tool. The technical preview was for the Mac and for develop software for the Mac.
Interface Builder is nice, I remember trying to develop GUIs on Amiga with intuition.library and wished that there was a drag and drop program to build the source code. Running NeXTSTEP 3.3 on Virtual Box and trying to get it running on my early 2000s laptop :)
If folks had guess what turnaroud NeXT would go through, most likely my thesis would have been something else.
Most of these systems failed not due to technical limitations, rather by poor management decisions that ended up killing their adoption.
Likewise in the UNIX world, my favourite ones are the ones that went out of their way to not be yet another UNIX V6 clone with X, like IRIX, NeWS and NeXTSTEP.
I can provide you the public statement on that, if you feel like not searching yourself.
and i believe what you say about java and wikipedia. it just shows again that the distinction is not obvious.
i found this discussion on stackexchange: https://softwareengineering.stackexchange.com/questions/3352...
but reading that doesn't help me to tell the distinction between java and smalltalk either. the point appears to be that all OO is message passing, and the only distinction as far as i can tell is that java doesn't have extreme late-binding of all things, but that is something i can't know just by looking at the language. it's a hidden implementation detail. not being able to tell how the message is processed is another feature that message passing is supposed to have, btw.
the stackexchange answer however also shows why i am not seeing any revelation when using smalltalk. if all OO is supposed to be message passing then it's no wonder, it all looks the same to me.
note that i don't want to argue either way. i don't know enough about this to make any kind of argument. and i am trying to figure out the right questions to ask so i can learn and understand more. your comment did help me move forward at least. thanks.
"Apple itself had a very nice system for UI development on Dylan that was arguable better in many way then the Next system. But when Steve Jobs came and they had Next, that wasn't developed anymore."
This one is misleading in a couple of respects. First, there was more than one Dylan development system at Apple: Leibniz for the Newton and Apple Dylan for the Mac (I think it was called "Hula" internally, but I may be wrong about which project got that name). Both were written in Common Lisp using MCL, but they were distinct projects with different goals. Neither had tools like NeXT Interface builder. The Lisp-based application builder that rivaled (and in my view surpassed) Interface Builder was SK8, which was unrelated to Dylan. SK8 was also written with MCL.
Dylan was not canceled because Steve Jobs returned with Nextstep. The cancellation happened several years before Steve came back and was part of Apple's normal product and project churn.
"Apple Dylan seems incredibly limiting and opinionated for no reason."
It didn't seem that way to me, but that's about all I can say to a vague subjective impression of this kind.
"I find it interesting the website lamenting its death only shows screenshots [2][3][4] of the "advanced" editor, rather than any successful applications made using Dylan."
There weren't really any successful applications made using Dylan, if you mean shipping products. It never got that far along.
There were projects written with Dylan that were successful on technical merit, but never shipped for reasons that had nothing to do with their technical quality. For example, the final review of bauhaus told us that we had met and exceeded every metric of success, but Apple management just didn't want to ship a Lisp OS for Newton, full stop.
But yes, Nextstep was dogfooded to a degree that Dylan was not, and it was much farther along than Dylan ever was.
"There were two teams fighting for delivering the OS, one using Dylan, other using C++, eventually the C++ team won the internal politics, even though the Dylan one was relatively ahead."
This characterization is misleading in a few ways. I wouldn't say the teams were fighting, and I wouldn't say the Dylan team was ahead, except in maybe a couple of narrow areas.
Initially all Newton development was done in Dylan (called "Ralph" at that time), except for work on the microkernel, which was C++, and the 7 "bottleneck" graphics routines from QuickDraw, which were C.
The Newton team did substantial work on the software system in Dylan, and it worked, but there were some objections. Larry Tesler objected that it was too much like a desktop OS and needed to be redesigned for a handheld device with touch input. Meanwhile, some discussion took place with John Sculley during one of his trips to Japan and when he came back he ordered Larry to move main system development to C++. Larry did so, but reserved a small group of programmers (of which I was one) to continue experimenting with Dylan to see what we might accomplish.
We accomplished too much: we ended up making a whole second OS in Dylan. That's not what Apple management wanted, and they canceled our effort. That was no surprise to me; what surprised me was how long they tolerated our experiment before pulling the plug.
Then again, Apple in those days was a sort of constellation of skunkworks projects. Apple engineers would go off in random directions when not under threat of looming deadlines, and cook up all sorts of wacky things, and it was sort of tolerated because sometimes those wacky projects turned into things that made money.
"> The platform which Dylan was originally designed for, the Newton had no C to begin with. These platforms had no development tools. The firmware and software runtimes were created outside. I would guess that there definitely C was involved for much of the firmware and that an on device Dylan runtime had C and assembler code."
I don't know of a Newton platform for which C tools did not exist.
The Newton originally targeted the AT&T Hobbit (https://en.wikipedia.org/wiki/AT%26T_Hobbit), which was a RISC chip designed to run C efficiently. By the time I was recruited the boards were using ARM chips, but the Newton microkernel was already written in C++. Perhaps there was a time when a Newton existed without a supporting C compiler, but I never saw it.
Now it might be that you meant that no C compiler or development tools ran on Newton hardware, and that much is true. The Dylan development didn't run on the Newton hardware, either. All dev tools ran on Macs and cross-compiled to the ARM platform.
I do want to apologize - I meant no disrespect in regard to the technical achievements of the Dylan team. In fact, I share the view that the Dylan project was ahead of its time in many aspects.
There is no way that Steve Jobs could have talked Furber & Wilson into this.
http://www.shawcomputing.net/resources/next/hardware/ns31_co...
i did see differences. the most awesome was when i wrote some code to respond to an http request, the code failed, the http request stalled, i fixed the code live, and then the http request resumed.
but i can do the same in pike if i tried, and i expect in lisp and other languages too.
and if that is the case then it supports my understanding that most OO languages use message passing. where then is the great revelation that comes from smalltalk?
> i did see differences.
Spot the difference. ;-)
> but i can do the same in pike if i tried, and i expect in lisp and other languages too.
Absolutely you can! You can even do it in C: write yourself a message-passing library in C. You might want to call it Objective-C. Or do a VM for Smalltalk.
> where then is the great revelation that comes from smalltalk?
The claim was not that the great revelation came from Smalltalk, but that it came from message passing:
>>> Message passing belongs up there with lisp, forth and pure functional programming as paradigms that are worth learning for "the profound enlightenment experience you will have when you finally get it."
Smalltalk isn't even mentioned in that little section about the enlightenment.
And in fact, Smalltalk's form of message-passing is pretty limited, it only just extends beyond method invocation and it certainly can be (and is) frequently used just like method invocation. If you want to do more sophisticated things, you mostly have to go via the DNU handler, which is a bit hacky.
And in fact, Alan Kay's famous OOPSLA '97 quip "I made up the term object oriented. And I can tell you I did not have C++ in mind." was followed immediately with the slightly less famous "So, the important thing here is: I have many of the same feelings about Smalltalk". https://www.youtube.com/watch?t=634&v=oKg1hTOQXoY&feature=yo...
And even message-passing is much broader: for example, with Higher Order Messaging, you can control how messages are delivered: to collections, on different threads, delayed, distributed (combine distributed + delayed and you get TeaTime/Croquet), conditionally only if the receiver understands the message, etc.
https://en.wikipedia.org/wiki/Higher_order_message
https://www.youtube.com/watch?v=GBtqQwcJoN0
And even that just scratches the surface. When you look at something like the Enterprise Integration Patterns, that's distributed asynchronous messaging, which opens up a whole other universe. Also: Erlang.
https://www.enterpriseintegrationpatterns.com
https://stackoverflow.com/questions/3431509/is-erlang-object...
The point is that it encompasses all of these things: synchronous, asynchronous, local, distributed, late-bound, early bound, point-to-point, broadcast, multicast.
And ideally, you should be able to select which kind you want on a case-by-case basis. With ease.
Rather than having to choose a different programming language.
Are you sure about that?
]pwd
objc4/runtime/Messengers.subproj
]rg malloc
]
And of course NeXT used objc_msgSend() in the kernel, to good effect, so that's pretty low-level.
I didn't want to suggest it was as far along as NextStep Objective C based system.
That same person also suggested that Post Jobs, with the move to next this was gone. But it seems that development was canceled even earlier.
I didn't know about SK8, I will look more into that.
>> i can't tell the difference
> i did see differences.
Spot the difference. ;-)
well the first refers to the difference between message passing and function calling. which i couldn't see because all languages i worked with are using message passing.
the second refers to the difference between smalltalk and other languages, which owes to the particular implementation of smalltalk, and not just message passing.
in summary, you are confirming what i thought i understood. it appears i need to do the reverse and actually explore languages that don't do message passing to see the difference.
That turns out not to be the case. C++ is not. Java is not.
Of course, many would say that those two are not object-oriented, so that way around you can make it work.
> which i couldn't see because all languages i worked with are using message passing.
That still is not the case. So your explanation for the contradiction in your statements also makes no sense.
> in summary, you are confirming what i thought i understood.
No, I am most emphatically not doing that, and what I've written makes that very, very clear. There is little I can add to that, I could only repeat myself.
Have a nice day.
i meant all the languages besides those. if you make a list of all known OO languages, most of them will be dynamic languages with message passing. C++ and java and a few others will be the exception.
> which i couldn't see because all languages i worked with are using message passing.
That still is not the case
do you know which languages i have worked with? which of those do not use message passing?
what I've written makes that very, very clear
well it appears we are talking past each other, and therefore it doesn't.
'what matters about an object is its protocol: the set of messages that it understands, and the way that it behaves in response to those messages. Nowadays, this is sometimes also referred to as the objectʼs interface. The key idea is that when we use an object, we focus on how it appears from the outside, and “abstract away from” its internal structure: more simply, that the internal structure of an object is hidden from all other objects. Thatʼs why I said “the set of messages that it understands,” and not “the set of methods that it implements.” In many languages they are the same, but I wanted to emphasise the external rather than the internal view.'
"Object-oriented programming: Some history, and challenges for the next fifty years" Andrew P. Black
https://doi.org/10.1016/j.ic.2013.08.002
So, a matter of emphasis?