walnutclosefarm 2 years ago

Smalltalk remains my all time favorite language. I started programming in the 1960s, with BASIC and FORTRAN (FORTRAN II, in fact, from McCracken's famous "Guide"), and before I quit coding professionally, implemented production systems in more than two dozen different languages. Wrote the most lines of code in Java, but the most interesting systems in Fortran, Pascal, Object Pascal (and one in Concurrent Pascal). Liked LISP least of all, followed closely by C++ and COBOL (although APL would probably be at the bottom, had anything I did in that strange elixir ever reach production - none did), but I loved Smalltalk. Unfortunately, Smalltalk arrived to too much hype before it's (potential) time, and was crippled as production language by it's image based development and deployment methodology. A truly elegant and sweet language coupled to a really awful engineering paradigm.

Thinking back on all this, I am astonished once again at how much has happened in computing in my lifetime (I am older than FORTRAN, e.g., so essentially all code every compiled has been compiled in my lifetime, unless you want to count Autocoder macros as compiled code).

  • Qem 2 years ago

    > Unfortunately, Smalltalk arrived to too much hype before it's (potential) time, and was crippled as production language by it's image based development and deployment methodology.

    I was exposed to image based through Pharo, and I've found the idea to be awesome, as it allows very tight feedback loops on development. I see people complaining because it was nontrivial to extricate a finished program from the environment and ship it to customers in a "tamper-proof" opaque form. What puzzles me is why didn't Smalltalk play a bigger role on the ascension of free and open source software, given what was a bug for proprietary shops (hard to ship a opaque binary) is actually a feature for copyleft development (fully inspectable source code together with full development environment included by default). The GNU-Smalltalk development appears to be mostly stale. The torch of free smalltalk is carried most by Squeak and Pharo today.

    • igouy 2 years ago

      > … nontrivial to extricate a finished program from the environment and ship it to customers in a "tamper-proof" opaque form.

      1) source code management

      Even ancient Smalltalk-80 provided —

      "Within each project, a set of changes you make to class descriptions is maintained. … Using a browser view of this set of changes, you can find out what you have been doing. Also, you can use the set of changes to create an external file containing descriptions of the modifications you have made to the system so that you can share your work with other users.

      The storage of changes in the Smalltalk-80 system takes two forms: an internal form as a set of changes (actually a set of objects describing changes), and an external form as a file on which your actions are logged while you are working (in the form of executable expressions or expressions that can be filed into a system). … All the information stored in the internal change set is also written onto the changes file."

      1984 Smalltalk-80 The Interactive Programming Environment page 461

      https://rmod-files.lille.inria.fr/FreeBooks/TheInteractivePr...

      2) deployment

      Not all software was shrink-wrap — plenty of high-value enterprise software.

      • walnutclosefarm 2 years ago

        Smalltalk images were fine for one-person development of single programs. Not really very manageable for teams, and modular development though. Not that these things couldn't be done - we certainly did it at IBM, when SmallTalk was the "thing" there for a while - but it never was very satisfactory.

        A lot of developers significantly younger than me seem to think that source code control was developed in the the last couple of decades, but in fact we did source code control, modular development, and build pipelines way back in the 70s - mostly with home built tools, but the capabilities began to be built out as soon as source code left card decks for permanent residence and in place modification on rotating storage. And SmallTalk was at best hostile to all those techniques.

    • Jtsummers 2 years ago

      You have to consider several factors:

      1. Information (and source code) was not so freely available as it became even by the mid-90s, when the internet itself started approaching ubiquity and the Web provided much greater access to information.

      2. A large part of the OSS movement has long focused on replacing Unix-like OSes with a FOSS Unix-like OS, which eventually meant GNU/Linux becoming the dominant system people rallied behind. This focus carries with it a language focus, C.

      3. Smalltalk in the 80s and through most of the 90s was not easily used freely, and implementing it carries its own costs even if you have people interested in it. Without the common experience of having used it, there is less of a desire to create a free version of it (see 2, the common UNIX and Unix-like experience shared by OSS developers molded and directed the movement, even if not consciously).

      If the Internet had been more widely available, Smalltalk more widely used and free (or at least much cheaper), then maybe we would have seen a different outcome.

    • hota_mazi 2 years ago

      Price is one of the main factors, for sure.

      But it's not just that.

      The image was actually a big turn off even back then, even before source control was even a thing.

      Even today, Smalltalk runtimes (e.g. Pharo) are extremely slow compared to other languages, now imagine how slow Smalltalk was forty years ago... I can tell you, it was very, very slow (I used it on NeXT back then). I'm talking "watch the window draw with your naked eye" slow.

      • oakpond 2 years ago

        > Even today, Smalltalk runtimes (e.g. Pharo) are extremely slow compared to other languages, now imagine how slow Smalltalk was forty years ago...

        It doesn't feel slow to me. I regularly use the VM on a Raspberry Pi and the GUI is snappy. On that same system I even use it to solve algorithmic puzzles, and I've been more often surprised that it isn't as slow as I had expected.

        So yeah, I'm sure it isn't the fastest language out there. However, "extremely slow" compared to other languages? It beats Python and Ruby most of the time. [1]

        [1] https://benchmarksgame-team.pages.debian.net/benchmarksgame/...

        • hota_mazi 2 years ago

          Well, saying that it's faster than the two slowest mainstream languages today is not exactly setting the bar very high :)

          • igouy 2 years ago

            What makes you think Smalltalk was sold on the basis of runtime performance?

            "… it is possible to write time critical, real-time applications while still maintaining access to the user-interface facilities of Smalltalk. In the ESM testbed, C language support has been provided both by a package of C-to-Smalltalk communication primitives, and by high-level C code debugging facilities accessible from the Smalltalk environment."

            1987 "USING OBJECTS TO DESIGN AND BUILD RADAR ESM SYSTEM'S" p200

            https://dl.acm.org/doi/pdf/10.1145/38765.38825

            • hota_mazi 2 years ago

              > What makes you think Smalltalk was sold on the basis of runtime performance?

              Nothing, because I never said anything of the sort.

              What I did say was that Smalltalk has always been very slow compared to other languages. It was true decades ago, it's still true today.

              • igouy 2 years ago

                Very slow compared to some language implementations to do some things, not very slow compared to others. So much for vague generalities.

      • andai 2 years ago

        >"watch the window draw with your naked eye" slow

        Sadly I have this experience on a daily basis with Windows 10's file explorer. I ran XP in a VM today and was amazed that explorer windows not only open instantly, but fully drawn. In W10 it takes half a second to even respond, and then another half second while it draws the UI elements one by one.

      • igouy 2 years ago

        > Price is one of the main factors, for sure.

        March 7, 1988 — "Smalltalk/V 286 is available now and costs $199.95, the company said. Registered users of Digitalk's Smalltalk/V can upgrade for $75 until June 1."

        https://books.google.com/books?id=CD8EAAAAMBAJ&lpg=PA25&ots=...

        > … I can tell you, it was very, very slow…

        And of-course you used the Smalltalk profiler to fix that?

  • aeneasmackenzie 2 years ago

    Usually people mention lisp and smalltalk in the same breath. What turned you off of lisp, especially as compared to smalltalk?

    • walnutclosefarm 2 years ago

      Neither the list paradigm, nor functional languages generally, ever really gelled in my mind, the way, say, OO did. Algorithms expressed in functional form in LISP always seemed contorted from their natural form, to me. So, mostly I found LISP to be an awkward, "unscannable" language. I could write it, and read it, but it always felt a little like reading and writing a foreign language to me, not something in which my mind was native.

      • baldfat 2 years ago

        I am the exact opposite :) I started learning languages with Basic, Assembly and Fortran and ended up loving all things Lisp.

    • ErikCorry 2 years ago

      Apart from being contemporaneous they have little in common. Lisp is functional, Smalltalk is object oriented.

  • nealabq 2 years ago

    I'm only slightly younger than you, and, like you, have worked in many languages. And my very favorite were the LISPs (zeta, common, scheme). But the dev env, projects, and my time in life were all part of that positive experience. I was in my 20s (a super learning time) working on my own code on Symbolics Lisp machines. Fortran/Ratfor were my least favorite, since that work was always maintaining code written (and barely commented) by someone I didn't know.

    Smalltalk and Erlang are my next choices. Same reasons as LISP.

eternalban 2 years ago

My god, Byte magazine. The internet generation probably doesn't appreciate just how difficult it was to be on top of CS outside of academia or SV in 80s and evens 90s. I remember there was one bookstore down in Wall Street and one day I saw the green and blue Smalltalk books. It was like finding a little treasure! Naturally I grabbed them both.

analog31 2 years ago

My mom subscribed to Byte, and I eagerly awaited every issue. My favorite feature was Ciarcia's Circuit Cellar but I read all of the articles. I was just learning BASIC in high school when the Smalltalk article came out. So I have to admit that I was utterly bewildered by OOP. Plus, I had no hope of actually trying to use it on any computer within my reach.

Years later, I finally got over the fear of OOP by using languages that let you kind of ease your way into it. Visual Basic was "object based" in that you could use pre-made classes, but had to buy a special version to make your own. Still, understanding the benefits of using classes was a good preparation for making them. Probably the point when I realized that I had been using OOP without knowing it, was when I started doing some moderately complicated programs in LabVIEW.

  • PaulHoule 2 years ago

    I borrowed Byte from the public library. I remember being really baffled by this Smalltalk issue.

    BASIC cast such a shadow over the 8-bit era that no other scripting languages were really significant on micros in the 1980s.

    In the early 1990s there was Perl, TCL and Lua that came in with the 32-bit age. Visual Basic was particularly interesting because it was tied to an object model that was bigger than Visual Basic itself. That is, you could write COM components in a language like C or C++ and script them in VB. For that matter circa 1990 there were quite a few scientific programming systems that revolved around scripting languages like MATLAB and IDL.

    LabVIEW, however, is in a special category of systems that represent a (usually) real-time calculation with a graph of operators. This kind of system is particularly prevalent today for sound synthesis.

ncmncm 2 years ago

Smalltalk looked at the time like it was going to be important. It had really good marketing.

Its main effect on the world, aside from being the implementation language for the Xerox UI that was demonstrated to Steve Jobs, seems to have been via its influence on the language Self, which then influenced Javascript. And here we are.

  • pjmlp 2 years ago

    Maybe if IBM had not rebooted their Smalltalk business into Java, Smalltalk would have been kept more relevant than it is nowadays.

    For the younger generations, the whole set of Visual Age IDEs were written in Smalltalk, SOM (the OS/2 COM like OOP ABI) had support for C, C++ and Smalltalk, making Smalltalk the kind of OS/2's .NET.

    Then Visual Age became Eclipse, and the Smalltalk business pivoted into Java.

    • nl 2 years ago

      > the Smalltalk business pivoted into Java

      Interestingly OTI (which was purchased by IBM in 1996 and did all the Smalltalk/Visual Age and later Eclipse) had a VM that could run both Smalltalk and Java bytecode:

      in order to accomodate Java execution, OTI developed what was called the UVM (or Universal Virtual Machine) whcih could execute both Smalltalk and Java byte-codes, and used Smalltalk to implement the Java primitive functions which were implemented in C in the Sun JVM.

      https://web.archive.org/web/20090611013334/http://talklikead...

  • ErikCorry 2 years ago

    Smalltalk is a major influence on Toit and Ruby.

    Toit has blocks (lightweight closures), single inheritance, everything-is-an-object (no primitive types).

    Like Smalltalk the Toit VM is dynamically typed, but unlike classic Smalltalk there are optional types and they are checked at compile time and run time if you choose to use them.

    The syntax is not much like Smalltalk though, and development is with conventional source files and compilation, not image based like Smalltalk and Self.

    (In Self the editor was inside the VM and you saved your work by snapshotting the entire VM state which is superficially attractive but makes it really hard to collaborate and use version control.)

    • igouy 2 years ago

      > you saved your work by snapshotting the entire VM state

      That doesn't seem likely, that wasn't the recommended approach to managing source code in Smalltalk — but I have no personal experience with Self.

      Seems like it might depend on which version of Self is being discussed.

      "To briefly recap, the Self transporter allows the programmer to take a program that adds some functionality to a snapshot and move that program to another snapshot. It accomplishes this task by writing the slots that comprise the program to a source file that can be read in and evaluated in the new snapshot to recreate the program."

      https://bluishcoder.co.nz/self/transporter.pdf

    • ncmncm 2 years ago

      Are Toit or Ruby important?

      We used to think Ruby would turn out to be important. Then it didn't, and Python reclaimed its niche. I have probably heard of Toit before, but am unsure.

      Snapshotting your VM state as the way to deliver programs was probably Smalltalk's chief failing.

      • igouy 2 years ago

        Lack of standardization across vendors was by-far the chief failing.

        > the way to deliver programs

        To judge whether that could be successful, we need to be more specific — deliver what kinds-of programs to what kinds-of end-users?

      • StillLrning123 2 years ago

        Microsoft Excel is very similar to this kind of deployment and is used _extensively_.

  • retrac 2 years ago

    Smalltalk influenced nearly every object-oriented language that came after it, by virtue of heavily influencing Lisp. The precursor to Common Lisp's Object System (CLOS) [1] comes rather directly after MIT Lisp hackers [1] encountered Smalltalk in the late 70s.

    Lisp probably counts as the first major language to have OOP, and along with Smalltalk, was the language that introduced OOP to the wider programming world. Bjarne Stroustrup knowing about Simula (which was always a little esoteric) and trying to turn C into a Simula-like language, is more the exception. Most OOP languages today can trace their OOP heritage to CLOS.

    [1] https://en.wikipedia.org/wiki/Common_Lisp_Object_System

    [2] https://en.wikipedia.org/wiki/Flavors_(programming_language)

    • davidgay 2 years ago

      > Most OOP languages today can trace their OOP heritage to CLOS.

      I'm extremely dubious about this claim and cannot think of any mainstream OO language this applies to (clearly not C++, Java or C#, nor of course Smalltalk, hence neither Objective-C nor Self nor Javascript).

      For further context: I learned about programming languages, did programming language research starting in the early 90s. CLOS, and multiple-dispatch especially were always a significant outlier.

      • lispm 2 years ago

        There are a bunch of different OOP mainlines. Some have early Lisp influence, long before CLOS. Some are more or less completely without Lisp influence.

        Simula, Object Pascal, C++, c#, ... (class based OOP with virtual functions)

        Smalltalk (message passing, classes)

        Lisp/CLOS (generic functions) -> Dylan, Perl, Julia, R, ...

        Actors, Self, JavaScript, ... (Prototypes)

        ....

    • pjmlp 2 years ago

      Not really, Smalltalk was influenced by the work being done to add OOP to Interlisp-D at Xerox PARC, LOOPS.

      https://interlisp.org/saved.html#history

      Besides Common Lisp, the only languages that have anything on their object model that resembles CLOS are Dylan, Clojure and now Julia.

      • lispm 2 years ago

        R, Perl and Raku, various Scheme variants use it.

        • pjmlp 2 years ago

          Since when does Perl 5 use CLOS?

          Regarding R and Raku I cannot say anything, but the CPAN package for OOP extensions I used back in 2000's wasn't it.

          • lispm 2 years ago

            It's not about using CLOS, since that is Lisp specific and the full thing incl. MOP is largish.

            But Moose is largely influenced by CLOS.

            https://www.perl.org/about/whitepapers/perl-object-oriented....

            some comment here on Hackernews :

            "Moose is back-ported Perl6 objects, which borrows heavily from CLOS and the concepts introduced in the Smalltalk traits paper. This is a bit of a simplification of the history, but the ancestry is present, documented and obvious."

            • pjmlp 2 years ago

              Fair enough, still one option among many others.

              A quick search gave me Moose, Moo, Class::Accessor, Class::Tiny.

              So kind of hard to make it the Perl OOP way.

              • ncmncm 2 years ago

                TIMtOWtDI, as it were.

  • AlbertCory 2 years ago

    > the implementation language for the Xerox UI that was demonstrated to Steve Jobs

    Sorry, I have to correct you on that. Or rather, clarify the proper construction of it, which is: narrow.

    In https://www.albertcory.io/inventing-the-future, I talk about Smalltalk a lot. It was not used for the Xerox Star, and there was only a limited demo of the UI done in Smalltalk. No one seriously considered building Star on it.

    However, you're right in that the PARC demo to Jobs did make heavy use of Smalltalk. That's because the demo was done by PARC and not by the Star developers, and they showed him the ideas that inspired Star, ideas that had existed for years before he came.

    • ncmncm 2 years ago

      My recollection is that Star came along rather later. Certainly Alan Kay would have wanted to implement Star in Smalltalk.

      According to the Arbiter of All Things, the demo was in 1978, and Star came out in 1981.

      • AlbertCory 2 years ago

        Alan Kay wasn't involved in Star, except as a PARC influencer.

  • e12e 2 years ago

    I think openstep, objective-c and cocoa owes a great deal to smalltalk. I'm not sure if objective-c ever was any better (or practical) than smalltalk/strongtalk/self (or Java) - but it's at least possible to dream of the macos going for smalltalk, not obj-c.

    • Jtsummers 2 years ago

      Objective-C had the primary benefit (over Smalltalk) of being a superset of C, which permitted immediate and easy interaction between Objective-C and C source code. It also integrated better (which was critical, Smalltalk doesn't force using the image model for source code, but it was typical) into existing development workflows. Those are the kinds of practical concerns that can't be neglected when considering language adoption, especially since NeXT (main early adopter) was building on the lineage of the Unix-family of operating systems.

      • e12e 2 years ago

        True enough.

        As for other descendants, ruby is of course deeply inspired by smalltalk.

  • linguae 2 years ago

    The Smalltalk community also had an influence on design patterns and testing frameworks that would later get picked up by C++ and Java programmers. If I recall correctly, the Gang of Four (the authors of the famous Design Patterns book) uses Smalltalk in its examples.

    • ncmncm 2 years ago

      Design Patterns has itself turned out not to be anywhere near as important as it seemed at the time.

      The only one I ever hear of nowadays is the "visitor pattern".

      Anti-patterns have more sticking power. Arguably all patterns are anti-patterns, since each identifies something one's language is too weak to capture in a library. As C++ got more powerful, the patterns vanished into ordinary library components.

      • mickeyp 2 years ago

        - Decorator pattern, as seen in Python's @decorators;

        - Factory functions, as seen everywhere, even if people don't bother thinking of them as such;

        - Memento pattern, a common way of implementing undo-able actions in applications that need it;

        - Proxy pattern, frequently used when you have a code-generated client that talks to a server from a template. Like generating REST/RPC client code that matches a server spec;

        - Visitor pattern, but you already mentioned that... but ironically enough, if you have pattern matching support in your language, it's much easier to use that.

        And that's just off the top of my head. If you use any of these you're no architecture astronaut, nor are you gilding your lillies.

    • rileyphone 2 years ago

      The Smalltalk community was also instrumental in the origin of Agile (before familiar bastardization by the industry) with people such as Kent Beck and Ward Cunningham (who also made the original wiki at c2.com).

    • infinite8s 2 years ago

      I first learned design patterns in the context of C++. After learning python I used to think that needing design patterns was a sign that your language wasn't powerful enough. However, now that I've taken the time to learn Smalltalk I feel that design patterns indicates that your language had the ability to model any kind of architecture you can imagine, and if needed you can reshape the language to make that easier (vs python where you would need to implement it in the underlying cPython layer).

  • cmrdporcupine 2 years ago

    I don't see the Self influence in JS.

    Perhaps you mean because of prototype inheritance? But the form in JS doesn't look anything like the form in Self. Or particularly thought through at all, really. I fear that Eich may have implemented prototype OO by accident almost?

    I have a whole book on prototype OO from the 90s, and the languages in there are much better thought through (Self wasn't the only one or the first one. Actually even Smalltalk 72 is kind of prototype-OOish).

    In other respects, syntax and scoping model etc, I don't think original JS looks anything like a Smalltalk-descended language.

    • Jtsummers 2 years ago

      > I don't see the Self influence in JS.

      I think Eich's own words may be helpful here: https://brendaneich.com/2008/04/popularity/

      Maybe it was accidental, but he refers to it as being Self-ish. And refers to it as "a quickie love-child of C and Self".

      • BrendanEich 2 years ago

        I've co-authored a HOPL IV paper and given lots of talks, do some searches and you will find them (https://dl.acm.org/doi/pdf/10.1145/3386327). There's no doubt about this. I knew of Self and liked it but did not have time for multiple parent* slots. I didn't even have time to expose the unstratified (meta- in base-level) __proto__ property until 1997 in SpiderMonkey. I was aiming at Self + Scheme-ish (definitely "ish") first class functions because I had to interop with Java.

    • musicale 2 years ago

      I suspect Self and NewtonScript may have helped to popularize prototype-based OOP before JavaScript came around.

      And of course Self's JIT/VM evolved into HotSpot and probably influenced most future VMs including JavaScript.

  • jonjacky 2 years ago

    I recall Smalltalk had the first unit testing framework, which became a model for other languages.

  • Jtsummers 2 years ago

    And Self's JIT and VM technology went into Java.

    • ncmncm 2 years ago

      They did, but that was not a Smalltalk heritage.

      • pjmlp 2 years ago

        It surely was, here is some learning material.

        > Strongtalk is a major re-thinking of the Smalltalk-80 programming language and system. While retaining the basic Smalltalk syntax and semantics, it contains a number of significant advances, including:

        > The Strongtalk system was developed in secret in the mid-90's by a small startup company. Before the Strongtalk system could be released, the company was acquired by Sun Microsystems, Inc. to work on the Java® virtual machine.

        http://strongtalk.org/

      • twoodfin 2 years ago

        I'd disagree with that characterization. The earliest work in optimizing highly dynamic languages was done in Smalltalk[1] before continuing in Self. David Ungar was the through line and one of the original designers of Self.

        [1] https://www2.eecs.berkeley.edu/Pubs/TechRpts/1986/5376.html

        • lispm 2 years ago

          > The earliest work in optimizing highly dynamic languages was done in Smalltalk

          Hard to believe, given that optimizing native code compilers for Lisp were already available.

          • twoodfin 2 years ago

            I’ll accept “of the specific thread that led to HotSpot” as a qualification, sure.

      • pinewurst 2 years ago

        Not true as the ParcPlace SmallTalk(s) were all JITed.

  • PaulHoule 2 years ago

    Other object oriented languages too.

    • ncmncm 2 years ago

      Objective-C, maybe. Not C++ or Java, which trace their lineage to Simula, which Smalltalk also cribbed from. But it is hard to see Objective-C as important, limited as it is to a walled garden.

      It also once seemed like "object-oriented" would be important. Now it is recognized as a niche technique.

      • dunham 2 years ago

        According to one of the developers of Java, Java was also inspired by Objective-C:

        https://cs.gmu.edu/~sean/stuff/java-objc.html

        • pjmlp 2 years ago

          Yes, Java is basically the semantics of Smalltalk/Objective-C, with the syntax of C++.

          The way dynamic code works (classloader, reflection), methods being virtual by default, interfaces, the JAR archives (think NeXT app bundles),... all that is Smalltalk/Objective-C influence.

      • Apocryphon 2 years ago

        Object-oriented programming has been important for like three decades now, for better or for worse, and if it's so "niche" now, what paradigm has replaced it?

        • ncmncm 2 years ago

          The world (well, most of it) has recognized that "paradigms" are themselves niche. Of mainstream languages, only Java still tries to shoehorn all programs into its "paradigm".

          • Apocryphon 2 years ago

            What world are you posting from exactly

            • ncmncm 2 years ago

              The one where C++, C, Java, JavaScript, Python, and Fortran are the mainstream, non-niche languages. Several of those have some support for an OO style, but only Java tries to force it on you.

      • linguae 2 years ago

        There is a GCC Objective-C compiler that has existed for a long time, and a large portion of the Cocoa API is available in GNUstep, an open source implementation of the OpenStep API. It’s long been possible to use Objective-C outside of NeXT, Mac, and iOS development, though admittedly Objective-C hasn’t had the same level of adoption as contemporary object-oriented languages such as C++ and Java.

        • ncmncm 2 years ago

          I have never heard of Objective-C actually being used in anything I know about, outside the walled garden.

          • rileyphone 2 years ago

            Ever heard of the World Wide Web? https://github.com/cynthia/WorldWideWeb

            • pjmlp 2 years ago

              Created on a NeXT workstation, the Objective-C implementation was never ported to other platforms, Mosaic was implemented in C.

              https://en.wikipedia.org/wiki/Mosaic_(web_browser)

              • rileyphone 2 years ago

                Still, the Web might have never existed without Objective-C, which is moreso my point. From [0]:

                > A second phase would almost certainly involve some programming in order to set up a real system at CERN on many machines. An important part of this, discussed below, is the integration of a hypertext system with existing data, so as to provide a universal system, and to achieve critical usefulness at an early stage.

                > (... and yes, this would provide an excellent project with which to try our new object oriented programming techniques!) TBL March 1989, May 1990

                Objective-C had a wonderfully pragmatic approach to OOP, though it remained tied to the systems it was on because of the standard object libraries that enabled it. NeXT promotional materials really liked to showcase its suitedness to rapid application development, whether Jobs himself doing so [1] or in a staged competition with Sun [2]

                [0] https://www.w3.org/History/1989/proposal.html

                [1] https://youtu.be/rf5o5liZxnA?t=1391

                [2] https://www.youtube.com/watch?v=UGhfB-NICzg

                • pjmlp 2 years ago

                  The Web would have existed in another form.

                  Hypertext systems preceded it by decades.

                  Objective-C has great as it might have been, didn't brought much to the table to those used to the Windows or Mac IDEs for GUI development.

                  The Next vs Sun marketing video wouldn't have been the same when placed against HyperCard, Visual Basic, Delphi or C++ Builder.

                  NeXT was almost bankrupt when they were pivoting into OpenStep, and not only was Java born out of Objective-C influences at Sun during the OpenStep days, Java EE was born from the ashes of an Objective-C framework for distributed computing at Sun.

          • Apocryphon 2 years ago

            Mac software aren't inherently walled garden.

  • macintux 2 years ago

    Objective-C was directly influenced by it.

AlbertCory 2 years ago

I first wrote a Smalltalk program in 1977. That was how I learned what object-oriented programming meant. There was a prototype of some Star concepts done in Smalltalk, but no one seriously proposed actually doing Star in Smalltalk. I don't think the Smalltalk group even wanted that level of headache.

https://www.albertcory.io/inventing-the-future to immerse yourself in that world.

datavirtue 2 years ago

Limited print space definitely contributes to quality. I'm so sick of run-on SEO text. Reading a good magazine always reminds me of how unusable the web is.

pkrumins 2 years ago

For over a decade, every August, Byte magazine published columns covering one programming language. Here’s a list of years and languages covered:

8/77 - APL

8/78 - Pascal

8/79 - LISP

8/80 - Forth

8/81 - Smalltalk

8/82 - Logo

8/83 - C

8/84 - Modula 2

8/85 - Declarative programming

8/86 - Object Oriented programming

9/87 - Misc programming

  • musicale 2 years ago

    Nice list. Too bad they didn't keep going.

    And too bad they covered Modula-2 rather than the Oberon system which was (and is?) quite amazing and compact.

    I wonder what they would have covered if they'd continued? Maybe.... C++. Objective-C. Ada. Apple languages: HyperCard/HyperTalk, Dylan, NewtonScript... Object Pascal (later Delphi.) Oberon. Scheme. Tcl. Perl. Python. HTML. JavaScript. Ruby. ...

    The recently-featured-in-HN BYTE Lisp issue actually included an 8-bit Lisp implementation for the 6800 (though you had to order the full listing separately.) Or you could write your own based on the article.

    • pjmlp 2 years ago

      Modula-2 was already a great language, and it didn't grew that big on PC because Turbo Pascal around 5.0 time frame is basically Modula-2 with case insensitive syntax, and after being merged with Apple's Object Pascal design, grew from there.

    • Jtsummers 2 years ago

      It wasn't an either/or with Modula-2 and Oberon, Oberon itself didn't exist until three years later. But yeah, would've been cool to see that continue.

      • musicale 2 years ago

        Precisely - the timing of Modula-2 was unfortunate given the awesomeness of the Oberon system which succeeded it.

        But Wirth's systems are terrific in general and highly educational. For example, I like Wirth's TRM/RISC5 (not to be confused with RISC-V from Berkeley et al.) processor designs[1] and the Lola hardware description language. So maybe a followup on Oberon/(Wirth)RISC/Lola/etc. would have been justified.

        [1] https://people.inf.ethz.ch/wirth/Lola/index.html

        Having a system which is compact enough to understand from the gate level to the application level is remarkable. (I'm also a fan of nand2tetris, etc..)

        Sad that BYTE shut down for good in 2013.

infinite8s 2 years ago

Alan Kay has often lamented that Smalltalk was effectively frozen after it was released to world, effectively freezing some of the implementation choices due to the tiny (in current day terms) hardware that was available to them. My question is what are the next great ideas now that hardware is so cheap it's almost disposable (and I'm not talking about the mechanistic progression of today's languages, where no language/system is written in itself and has a model of itself and any substantial program needs an army of people to implement it). Where is the Sagrada Familia or Empire State Building version of programming of today? I feel DynamicLand is a hint of this kind of ubiquitous idiosyncratic computing, similar to the democratization of literacy. Are there any other hints out there?

oakpond 2 years ago

Aside from the development environment, I find the language itself also very elegant. While the evaluation rule for binary messages can be very counterintuitive (always left-to-right, so 1 + 2 * 3 = 9), the rule is simple and easy to learn. Keyword messages are something else that I think is just very nice, and the evaluation order of messages (1. unary messages, 2. binary messages, 3. keyword messages) often lets you create large composite expressions without the need for (m)any parentheses.

digitalsankhara 2 years ago

Thanks for this link. I love smalltalk and had an opportunity to use a commercial implementation (Cincom Smalltalk) whilst working in biodiversity information. I found the development environment to be really productive - esp. during my self learning period. Having everything to hand in one environment/image which I could live in all day and do editing, debugging, REPL and data was compelling. Saving the whole system state in the image for the next days work was great too.

CrazyPyroLinux 2 years ago

Thoughts on Functional Programming just had a short episode about Smalltalk. The thesis was that its ratio of functionality to small size was due to the willingness to repeatedly rewrite it in pursuit of improvement.

https://ericnormand.me/podcast/rewrites

jjtheblunt 2 years ago

1981 not 1984

steve_john 2 years ago

Byte magazine was an early microcomputer magazine, influential in the late 1970s and throughout the 1980s because of its wide-ranging editorial coverage.

PerilousD 2 years ago

I just tossed this issue out along with maybe a hundred others last month :-)

  • Apocryphon 2 years ago

    Why are you smiling? You should've donated them!

    • PaulHoule 2 years ago

      Magazines like Byte and Creative Computing were perceived as ephemeral by libraries, particularly academic libraries, and were discarded quickly. My mom threw most of mine out when I went to college.

      In the mid 1990s I tried to get 1979 issues of Creative Computing and couldn't find any academic libraries that could offer them for interlibrary loan.

    • AdmiralAsshat 2 years ago

      To whom? Internet Archive would be the obvious recipient, and they've clearly already digitized it.

    • andrekandre 2 years ago

      i wonder whats stopping anyone from doing a re-print of these magazines... not enough demand?

      • retrac 2 years ago

        Still under copyright.

        • andrekandre 2 years ago

          i see... i wonder who holds it still, it would be nice if they offered re-prints

varjag 2 years ago

Palantir ad on page 32

  • minsight 2 years ago

    Interested in COBOL-based accounting packages?