NeXT Computers | Hacker News Reader

NeXT Computers

nextcomputers.org

224 pointsbehnamoh150 comments

One of the things that amazes me about NeXTstep is the fact that it brought together many technologies developed by Xerox PARC. Unlike the original Mac, where the dominant PARC influence was its GUI, NeXTstep had other PARC-inspired technologies, such as Ethernet networking, Display PostScript (while PostScript is an Adobe product, the creators of PostScript were ex-PARC researchers who worked on a similar page description language called InterPress), and dynamic, late-binding object oriented programming, albeit in the form of Objective-C rather than Smalltalk. These technologies created a solid foundation that is still relevant today; macOS more or less is still influenced by NeXT despite gradual changes.

Of course, there’s also the Unix foundation of NeXTstep, which importance cannot be understated, especially during the rise of the Unix workstation in the 1980s and the 1990s. This gave NeXTstep (and later Mac OS X) a user base who could take advantage of PARC-inspired environments while at the same time being able to take advantage of the vast Unix ecosystem.

Yes, the Xerox PARC and Unix philosophies are different and sometimes contradictory. However, it’s impressive how NeXT was able to bridge these worlds; the execution was great, and once again macOS serves as a living legacy.

As an aside, personally I’m curious about an alternative timeline where NeXT decided to go all-in on Smalltalk, building a “Smalltalk OS” with no Unix foundation, similar in philosophy to the Lisp machines of the era. There was certainly research going on in the 1980s to improve the speed of Smalltalk; part of this was continued with the development of Self by David Ungar and other researchers. NeXT probably still would’ve had the same market challenges, and the lack of a Unix foundation may have further hurt adoption. But from a purely technical standpoint a polished Smalltalk desktop would be amazing to see and use.

What amazes me about NeXTStep is that you could actually run that desktop, running Display PostScript, in grayscale, admittedly, but with the full motion window dragging and everything else, on that display, with 8MB of RAM. Oh, and on a 25MHz '040.

Oh, yes, it was tight. But it was eminently usable (including Project and Interface Builder) with 20MB of RAM.

Heck, I think XClock is challenged to run in 20MB today.

NeXT and its successor, the modern Apple, have done incredible things with low amounts of resources. It feels nothing short of miraculous that the first few iOS devices could do so much in just 128MiB of RAM. No Android device has ever managed with that little!

The power of Objective-C?

I would say it's more the power of incentives, really. Android has historically never had the performance investment that Apple has put on their platform. If anything, early Android was much closer to iOS in terms of hardware specs and diverged quickly as they were unable to keep their resource usage down.

I wouldn't call the JIT, AOT and PGO efforts nothing, and stuff like project butter.

On the other hand going with a basic Assembly interpreter for Dalvik, when Nokia and Sony-Ericson already had JIT compilers for Symbian, while claming Android was better, no comments.

Likewise when comparing Symbian Series 60 3rd edition phones with Android.

There are plenty of smart people who work on Android system performance, unfortunately the work put into iOS overshadows it.

I thought the HTC Dream/G1 also had 128 MB RAM, but you're correct - it had 192 MB! :)

Symbian, Windows Phone did just fine with C++, and also .NET.

The power of AOT compiled languages instead of plain interpreter.

Apparently the original Android as it was bought by Google, was planned to use JavaScript, then they pivoted into Java, and it took decades until they got any kind of good AOT/JIT story (starting with Android 5).

Yeah but it couldn't multi-task could it?

I don't think an Android device with that much RAM would manage much multitasking.

iPhone OS actually could multitask with jailbreaking, though you quickly discovered the limitations of that amount of RAM.

This is less of an issue today (although there aren't very many jailbreaks to take advantage of it) but back then it was pretty clear the device ran with very little RAM to spare. The best tweaks were fairly simple when it came to RAM usage but true multitasking or other things that stayed resident generally had a massive hit on system performance.

Well, NeXTstep could multitask in 8MB of RAM. And do it well in 16MB.

I mean the concept of multitasking takes basically no overhead. The question is what resources your "average app" takes. On NeXTSTEP those requirements were quite low.

Windows Phone and Symbian could.

'030 even.

I thought some of this was wrong but it turns out the BeBox lore is leaking into my NeXT memories. Wikipedia says it was a 60830@25MHz.

And the '030 varieties performed admirably well, even after the '040 & '040 Turbo varieties appeared. Our school had a bevy of cubes, and those were the primary workstations for three years until they opened a lab full of slabs before our senior year. The best part was having our user directories on a main server, and we could log in to any campus box and have access to our account. 30 years later & I still can't easily do that with the Macs on my home network.

> Heck, I think XClock is challenged to run in 20MB today.

Assuming you mean the 'xclock' binary you'd find in Xorg installations, it seems to use about 8MB of RES memory. But keep in mind that it drags in a bunch of libraries (objdump shows Xaw, Xmu, Xt, X11, Xrender, Xft, xkbfile and the math and C libraries as direct dependencies) and those drag their own (ldd shows 26 libraries) and all of that stuff add to the memory overhead for their own purposes even if at the end xclock didn't use them. Chances are an xclock reimplementation that talked the X11 protocol directly, used only the minimum functionality needed to display the clock lines and was statically linked to some minimal C library without any external dependencies would use much less memory.

Though even that would probably feel as too much memory since a lot of the memory used by a program in a Linux system relies a lot on what is already there - including the hardware and kernel drivers.

(which is also why these articles comparing memory usage between various desktops tend to make zero sense as they measure the entire system memory usage, the largest part of which is outside the control of the desktop environment in the first place and in most cases will vary between different computers even with the same distro)

Back in the day with i686 Linuxes you ran terms with screen under 8MB of RAM and lots of SVGAlib software.

I had a Pentium 1 laptop with 8MB of RAM in early 2000s (bought it for very cheap, my first laptop) running Slackware with Window Maker and Emacs :-)

Wmaker and Emacs? You did a custom kernel build right?

For being something to brag against, you used XEmacs, I guess. Or X-compiled Emacs, in order to be a "big" accomplishment. UXTerm+Emacs under the CLI was "big", but manageable; the X build (even the Athena or Lucid one) wasn't a light thing at all.

Not quite, but close. 12 megabytes is still much, much more than is easily explainable. Here is xclock on a 36 megabyte m68030, hosted on the same machine (so be patient).

On the other hand, modern OSes do a pretty good job of hiding resource abuse with excellent memory management.

http://elsie.zia.io/xclock.png

I remember people complaining about how slow the magneto-optical drive was.

By the time they ditched the MO-drive as the default, NeXT already had a bad taste in people's mouths, esp. at the introductory price of US$6.5K.

It's because they weren't running everything on top of Electron. :)

It wasn't because Jobs was such a great UNIX fan, rather as must have for the Workstation market, that NeXT wanted a piece of.

"NeXT meeting strategy"

https://youtu.be/KRBIH0CA7ZU

Or for a bigger overview,

https://news.ycombinator.com/item?id=34449912

However you're right, it is one of the best mixtures from both worlds.

Xerox PARC did port their environments into UNIX, Mesa/Cedar, Interlisp and Smalltalk, but it was already too late to make a difference.

The really amazing thing was how after SJ returned to Apple, for a couple of years, the Apple Dev Keynotes were just re-hashing of previous NeXT keynote addresses.

It still kills me that Adobe reneged on their promise of a free Display PostScript license, thus killing Rhapsody and "Yellow Box" for Windows (and it's still hilarious to me that that colour was named for Bill Gate's rude response when asked if Microsoft would develop software for NeXT, "Develop for it? I'll p** on it."

Adobe was in a similar place, Sean Parent from C++ fame had a very important role to change that, and bring Photoshop into OS X.

Check his interview on "ADSP: The Podcast",

https://adspthepodcast.com/2021/05/21/Episode-26.html

https://adspthepodcast.com/2021/05/28/Episode-27.html

https://adspthepodcast.com/2021/06/04/Episode-28.html

As for Rhapsody and "Yellow Box" for Windows dying, not sure if it would make a difference, OpenSTEP also did not work out that well, not even for Sun, other than being an influence to Java and Java EE (originally an Objective- C framework).

By the way, my graduation thesis was porting an OpenGL based particle engine from Objective-C/NeXTSTEP into C++/Windows 95, because the university department was getting rid of their Cubes, at this time there were no hopes for NeXT.

Yes, bit there could have been new life if all the NeXT devs had gotten their promised entrée into the Windows market as scheduled. Anderson Financial Services in particular were looking forward to a big payout for selling PasteUp.app license.

The notable NeXT code considerations at Adobe are:

- they lost the source code to Glenn Reid's nifty "TouchType.app" - they couldn't be bothered to revive the NeXT source code for Altsys Virtuoso which Macromedia Freehand was based on

It was a bit wild to see old demo videos of Project Builder, Interface Builder, and Cocoa Bindings under NeXTSTEP functioning more or less exactly like they would when I first encountered them in OS X around a decade later. It changed how I thought about the state of computing in the late 80s/early 90s, which had previously been shaped by my first computer use on System 7.5 in 1996.

Side-by-side screenshots of NeXTSTEP and Windows are particularly jarring. NeXTSTEP came out in 1989, and its contemporary was not even Windows 3.1, but 2.11

This is what Microsoft was serving up [1].

This is what NeXT accomplished. [2]

[1] https://en.wikipedia.org/wiki/Windows_2.1x

[2] http://toastytech.com/guis/ns10about.png

Don't forget though that NeXTSTEP was also running on workstation-class hardware and priced accordingly (~$6500), vs. Windows running on late 80s commodity PCs (probably ~$1500-$2000) with lesser specs. For that kind of cost difference NeXTSTEP had better have looked and performed better.

A better comparison would be the Motif/CDE GUI that commercial Unix workstations were using at the time on workstation-class hardware. I think NeXTSTEP still wins on style, particularly since X desktops were a garish mix of raw X, Xt toolkit and Motif apps all coexisting.

Bill Gates was so worried about Steve & NeXT that Windows 95—often criticized as ripping off MacOS—is a much more direct ripoff of NeXTSTEP.

That's a terrible comparison. Windows 2.x ran on much cheaper and weaker hardware. It required only 512KB of RAM and ran comfortably in 1MB while the smallest amount Next computers came with was 8MB.

There’s the technology, and then there’s style. And stylish NeXTSTEP is…

Your comment reminded me of this wonderful demo of NeXTSTEP 3 by Steve Jobs himself: https://www.youtube.com/watch?v=4UiGnpmwAJk

> “Smalltalk OS” with no Unix foundation

I think it gets even better if you integrate Smalltalk and Unix, nee, Plan 9, rather than using one as the foundation. Let's call it "Plan A from Userspace".

Start with a universal hierarchical namespace that subsumes memory, disk, and the network, integrated into the programming language[1]. But then don't do POSIX byte-oriented API, but rather a composable REST-like object-oriented API[2]. Add a variant of pipes/filters that doesn't just extend from bytes to (flat) objects, but can also handle hierarchies and polymorphism efficiently[3]. Combine them all: http://objective.st/Publications/

[1] Polymorphic identifiers: uniform resource access in objective-smalltalk https://dl.acm.org/doi/10.1145/2508168.2508169

[2] Storage Combinators https://dl.acm.org/doi/10.1145/3359591.3359729

[3] Standard object out: streaming objects with polymorphic write streams https://dl.acm.org/doi/10.1145/3359619.3359748?cid=813164912...

Basically Inferno and Limbo, although Tk based UI isn't that great.

Not really close, no.

If it really has to be Smalltalk, then a Tektronix 4404.

Yeah, not really close either...

You're missing the bit about integrating the two.

> Of course, there’s also the Unix foundation of NeXTstep, which importance cannot be understated, especially during the rise of the Unix workstation in the 1980s and the 1990s. This gave NeXTstep (and later Mac OS X) a user base who could take advantage of PARC-inspired environments while at the same time being able to take advantage of the vast Unix ecosystem.

A UNIX ecosystem built on top of Mach.

Both macOS and iOS continue to use a BSD-derived POSIX compatibility layer on top of a Mach microkernel - just like NeXTSTEP did.

No, not quite. The macOS/iOS kernel is extremely Frankenstein-y (not meant in a derogatory way), with the majority of codebase being extremely Apple-specific, and bits and pieces originally taken from Mach and BSD. In particular, there is no microkernel, and there never was. Mach itself was never used as a true microkernel in a commercial setting, with the first such implementation--Mach 3--showing significant real-life performance problems. As such, there is no "BSD on top of a Mach microkernel". It is and has always been a fully monolithic kernel with some subsystems originally derived from Mach (Open Group's Mk 7.3), some from BSD (FreeBSD 5), and the rest developed in-house over the years. Even the layerings aren't always clean, with "on top of" often morphing into "alongside" or "intertwined with".

What is interesting about Mach to me. Is that now 40 years later it's returning too it's roots of hosting multiple OS's on a single hardware architecture. Apple being able to design to M series chips to match Mach's paper over Mach's deficiencies and leverage it's strength I find very exciting.

Originally it was meant to be the foundation computing layer for a campus full of devices.

The BSD choice dates back to the original ARPA(DARPA?) grant they wanted the Mach microkernel with a BSD interface to prove the viability of the concept of Mach.

The first Smalltalk JIT was written for the 68020, so the NeXT hardware would have been suitable.

EDIT: OTOH, The Tektronix AI Workstations had already been on sale for a while by that point and had not been all that successful. They ran Smalltalk on top of a UNIX-like OS, not directly on the HW.

> As an aside, personally I’m curious about an alternative timeline…

This sorta happened at Apple (and IBM and Motorola) with the OpenDoc/Taligent initiatives. With the return of the Jedi however, Master Steve axed OpenDoc at Apple, to much chagrin of those involved.

Some of that hostility became internet famous, I am sure most of you have seen the video from the conference back then.

https://www.youtube.com/watch?v=oeqPrUmVz-o#:~:text=I%20thin....

It is interesting how (in the video) Steve explains the decision: the Smalltalk way doesn't fit into an overall cohesive vision that allows you to serve the majority of people.

I think he got it right. The Mac/Win ways of Apps is the right way to slice and dice these issues. I do use Emacs every day. I do feel the Smalltalk way and I like it. But it's not the "right" way; just not.

The best concepts of integrating a terminal/shell CLI driven environment with a GUI and together with on-the-fly manipulation of ENV variables and objects based on those was actualized by the Amiga. Unfortunately Commodore went bankrupt.

I think a Smalltalk-based version of the NeXT computer would've killed it as an internet device. With the Unix base and C compiler, NeXT users could join Usenet et al. when the device was introduced with a few downloads and make invocations (after the initial diehards did the grunt work of porting).

NeXT already was a killer Internet device. TBL invented the WWW on it after all.

Nope - if NeXT arrives as a Smalltalk-based device, much open-source/internet software does NOT get ported to run on NeXT. A few years later, TBL picks some other workstation to develop WWW.

CoreGraphics often emphasizes it's ability to draw PDF, I guess that has to do with the Display PostScript lineage as well.

The fancy names and the layering makes it a little tricky to understand. The core of the imaging model is called Quartz. It provides support for rendering 2D shapes and text. Its graphics rendering functionality is exported through the Quartz 2D API, which is implemented in Core Graphics. Quartz is also used for window management: the Quartz Compositor, a lightweight window server, is implemented partly in the WindowServer application and partly in the Core Graphics framework. Quartz 2D uses PDF as the native format for its drawing model. In other words, it stores rendered content internally as PDF, which facilitates features such as automagic PDF screenshots, export/import of PDF data natively, and rasterizing PDF data. Quartz 2D also does device-independent and resolution-independent rendering of bitmap images, vector graphics, and anti-aliased text. NEXTSTEP's window server was based on Display PostScript, so was Sun's NeWS (~1986).

NeWS wasn't based on DPS. It's a full display server based on the PostScript Red Book with some extensions (canvases, lightweight processes and sync primitives, events, classes, garbage collection). This allows to write applications in this extended PostScript or in other programming languages, using a preprocessor, such as cps for C or lps for Scheme-48 and Allegro LISP, that generates PS snippets that get sent to the server.

I remember seeing NeXT for the first time in person, in my college computer store, back in the late 80's. When it first caught my eyes, I didn't know what it was, and I couldn't believe it was actually a computer, seeing the black cubical case and very futuristic looking monitor in time when most of us were running either DOS on IBM/clone or running early Macs. Linux wasn't even in existence back then, I had an Amiga, and the only advanced workstation that I've seen until then were Sun workstation running X11, if I remember. I was in shock for few days afterward , when we were accustomed to boring beige box PC, and even my Amiga, which I was so fond of, almost felt obsolete and dated. (Of course, I'm still a big fan of Amiga, but I don't think I've ever felt like that about a computer like I did with NeXT).

Frog Design had traveling exhibit called Frog Art. The gallery on my college campus ran the show. There was a NeXT cube on display and turned on. There was only a login screen. One could try to login and when the credentials were rejected. The login window jogged left to right and erased the entries like an etch-a-sketch. That completely knocked my socks off. That pretty much inspired me with the notion that going forward we would only understand technology through analogy.

For anyone interested in NeXT, I very strongly recommend Randall Stross's "Steve Jobs and the NeXT Big Thing"[0]. The book -- written when NeXT was barely breathing and Jobs had been left for dead -- is extraordinary, and I think much more revealing of Jobs than Isaacon's biography of him. (Having read Stross, it is galling how little ink Isaacson dedicates to NeXT, as it's impossible to imagine that Jobs' experience at NeXT didn't shape him upon return to Apple!) If you're curious, we also discussed NeXT on Oxide and Friends, very much informed by Stross's book.[1]

[0] https://www.goodreads.com/en/book/show/226316

[1] https://oxide-and-friends.transistor.fm/episodes/next-object...

I can't recall if it was this book or another book about Jobs/NeXT, but there was a section talking about the compensation for NeXT employees.

Jobs decided to do the egalitarian/open ideal wrt employee compensation - there was a publicly-visible spreadsheet that showed EVERY EMPLOYEE'S salary.

This openness worked in the beginning of the company when there were few salary levels. But after a few rounds of evaluation/promotion, employee salary levels diverged a lot. Grumbling ensued. Spreadsheet disappeared.

Oh, it was definitely in there! And in fact, my introduction to the book came by way of its discussion of compensation at NeXT: someone (still unknown!) on Oxide and Friends indicated that Oxide's compensation model looked like that of early NeXT -- and the dollar figure (adjusted for inflation) is even roughly the same! We recounted all of this in an On the Metal episode on Oxide and Friends.[0]

[0] https://oxide.computer/podcasts/on-the-metal/oxide-and-frien...

What truly turned NeXT into crazy story is Jobs's obsession on the fully automated construction line. If the young Jobs's could have settled for the original color of the CAMs it may have been a recoverable issue. Jobs's insistence on a better color for the CAMs threw off the tolerances of the machinery when they were repainted.

Choose your battles wisely. Jobs only succeeded in hardware after hiring Tim Cook.

It would be fun to see this episode transcribed. I listened to it back in the day when I saw it on Twitter Spaces, but there's a lot of interesting stuff in there.

I second the recommendation for Steve Jobs and the NeXT Big Thing. Really fascinating book. I love books that are written during an event because they lack the hindsight of books written once time has passed so they have different perspectives than later books on the topic.

I’ll never forget Siracusa's review of the book in his hypercritical podcast.

His opening line paraphrased Steve’s interview regarding Sculley: “what can I say, he hired the wrong guy. (Isaacon)”

Thank you for turning me onto this! I found and listened to the episode[0], and the review was outstanding: I really didn't like the book, and it was frankly a relief to hear Siracusa just absolutely light the book up. Thank you for pointing to it!

[0] https://hypercritical.fireside.fm/42

You’re welcome :) one of the finest moments in podcasting.

Or David Pogue for his nasty comment about SJ using a ThinkPad to run Windows 95 (it of course ran NeXT/OPENSTEP).

Coincidentally I just listened to this Oxide episode a few weeks ago, and it was a great one! Thanks Bryan for the engaging discussions.

agree, its a great book to read and even with after-the-fact knowledge its really interesting and in-depth (very well researched)

it makes a really good (though long) business case study imo

For a while back 20ish years ago I worked at Apple with a team that had been NeXT developer support team for WebObjects and related things. They did OpenSTEP/black hardware support when I got there, and I still have some nice NeXT ephemera. I had a personal Turbo Color NextStation (called "the slab" by NeXT users) running NextSTEP 3.3 and OpenSTEP 4.2 + Y2K patches that I ran on Apple's corporate LAN in the late '90s and early 2000s.

It had a static IP and hostname and was bound to the corporate NetInfo domain and it was really nice to work with and really was a window into what would be Mac OS X. At one point I was running Rhapsody on a PowerMac G3 which still supported remote displays with -NXHost, running the app on slab with the UI on that thing. Mail.app bound to NetInfo was useful, the browsers were still being updated, and while setup took a lot of hand compiles, it was a really fun setup for a while.

Eventually they migrated from NetInfo to Open Directory, then dropped NetInfo support. The -NXHost remote windowing was based on Display PostSript, which was dropped with Mac OS X, and the slab got to be more limited, esp. with SSL/TLS evolving, and eventually it went into storage.

These days it's not useful on the modern web and I wanted to give it to a good home so about a year ago I traded it for help from a friend who's good with hardware for repairing/recapping an SE/30 I've had longer than the slab. Happy to see the slab and the SE/30 running again, they were both greats of their era.

I worked in a WebObjects shop that was combination of Sun, windows, NeXT, and eventually Mac OS Server 1. That shop was the best run shop I ever saw. The Sun was server running NIS, SMB, NFS. The NeXT and Mac OS Server machines NetInfo could be bound to NIS and shares were distributed using NFS or SMB. We also had NetAtalk configured for Mac OS 9 and lower. I have been trying to emulate that shop ever since.

Why was Doom developed on a NeXT?

https://www.quora.com/Why-was-Doom-developed-on-a-NeXT/answe...

Because if you could develop on a NeXT, you would develop on a NeXT :)

I am especially glad for the NeXTWORLD magazine archive[0], which provides an insight into the tone and priorities of computer people "back then"--not too long ago, but the culture has shifted.

Flipping to a random article, I came across mention of "BackSpace, a shareware program developed by NeXT employee Samuel Streeper," and dropped that into a quick web search, bringing up a demonstration of the BackSpace screensaver program[1]. Delightful!

0. https://www.nextcomputers.org/NeXTfiles/Articles/NeXTWORLD/

1. https://www.youtube.com/watch?v=fpyRYdzmtoo

Looking at old NeXT stuff as a current Mac user is funny, because here and there you spot something that has clearly been brought over nearly intact from 30 years ago. Like the color picker in that video! And I'm sure the ⌘T font pane, still used here and there, has the same origin.

Yes, it does, though it's kind of nice that it added a nifty feature where if collapsed to the minimum vertical height it become a line of drop-down menus to pick typeface and attributes and size.

Hey, thanks! I wonder how many years/decades that little feature's been there without me ever knowing it!

It's been there since the early days of Mac OS X --- during one UI flamewar on usenet on either comp.sys.next.advocacy or comp.sys.mac.advocacy I suggested it as a way to address the perception of "wasted" space and it showed up (probably coincidentally) in the next iteration.

I remember reading about the NeXT when I was a kid (late 80s). At the time I think I had an apple and was about to upgrade to a DOS PC with a 286.

The article I read said the computer would cost around $10K and have an optical disk, bitmapped display, a number of other exotic features, and was designed for science, math, and technology work.

Since my budget was $2K I really wondered how people could afford such machines. Years later, I worked with folks who had great NIH funding and they had an array of machines- including late (just before Apple acquired NeXT) HP workstations with the last version of NeXTStep. The team kept trying to get me excited about display postscript, the desktop environment, Mach, the APIs, and more.

I told them no matter how cool it seemed, I wasn't going to become dependent on an OS that required absurdly expensive machines. They later moved to Mac OS X, while I stuck with PCs running Linux and PCs running Windows.

I appreciate what NeXT tried to do, but I just could never get behind the whole stack.

That's ironic, since NeXTSTEP 3.1 and later did run on Intel x86 machines (although with a much smaller universe of supported hardware than Linux/Windows).

It ran on those machines, but the license cost was still something like $800 a seat if I recall. At a time when Linux was up and coming and starting to be quite usable for all sorts of things.

NeXT blew it on licensing costs for WebObjects, as well. They were early to the game on a very powerful application server, with a powerful ORM, etc. But it was hundreds of thousands of dollars to deploy it. I went to a seminar/training on it in early 97ish I think? And it was priced completely out of reach for what startups etc at the time could afford. So almost nobody used it. Just a few big companies (I believe Dell's website ran on it for a time.)

Yes, and Dell running on WebObjects was such an embarrassment that Microsoft strong-armed them into switching to MS products (which at first were totally broken).

I had similar thoughts and then jumped into SGI IRIX. Expensive as it gets, but frankly best computing experience I have had! No regrets.

I did have some dependence, but it passes and I am glad to have that perspective which can come from using distinctive computers.

I remember playing with SGIs as an undergrad and they seemed so "sexy" (from the case, to the window manager, to the demos).

In grad school we had a mix of machines. My professor bought the cheapest Indy's you could buy (minimal RAM and CPU), basically for the OpenGL performance. But next door another group ran a computer graphics lab and they had a bunch of high end SGIs (including an Onyx with InfiniteReality, https://en.wikipedia.org/wiki/InfiniteReality which was quite impressive for its day), as well as DEC Alphas running TruCluster. All these machines were maxxed out on hardware (huge RAM, max cores, large storage) and represented the best of what you could do with UNIX at the time. No Suns, though- the group had a terrible time with NIS and never touched Solaris again.

My wimpy laptop- a 486/100MHz could just barely run OpenGL (in software). When I finally got budget I spent $15K on 6 PCs to build my first cluster (1997-98). Everybody sort of laughed at the time (compared to their machines, my floating point wasn't so great) but it wasn't too long before nobody was buying "Real UNIX" machines any more.

NeXTSTEP, Solaris and Irix are my all time favourites in UNIX world, as they all tried to be something more than plain old UNIX + X Windows/CDE, there was a kind of soul to the whole experience.

Hence why I don't get those that try to replay the experience of using plain phosphor termimals + CLI, then why bother. I was there when they were new and don't miss the experience.

NeXTSTEP! I never had the experience and wish I had. It was like IRIX in that the team really pushed things and got results!

Running that stuff at it's peak was living a future for a while. Good times.

My NeXTstation Turbo is probably my favorite vintage machine to tinker around on. The workspace UI and the dev tools are just excellent for the era.

In the early 2000s my sysadmin boss still used his college days NeXT Slab as his desktop computer.

i bought a bunch of NeXTstations and a cube at a university auction in 2001 and had been using them for a few years after that.

This place ended up with a semi load from some college lab decommissioning it was ridiculous.

I'd love one, but the market prices are higher than my level of comfort, and my attention span is pretty well taken care of using virtualization (same goes for OS/2, BeOS, and AmigaOS)

yeah, what actually happend to get mine was that the university had a blind auction for a bunch of computer equipment. one "item" was a pallet full of NeXT hardware. a friend from the local linux user group and me put in a moderate bid and won. my friend picked a few machines from the pile, and i sold a few of them to others and for myself kept a slab or two, a cube (with a NeXTdimension card) and appropriate monitors. it was quite a nice catch for a decent price.

Every modern macOS computer is a continuation of the NeXT lineage.

I had to use Macs in college. They crashed just as bad as the PCs. I worked with a Mac programmer. He explained in bits and bobs all of the things he had to take care of to make a program look like it was doing four things at the same time. Oof.

My Mac friends kept trying to get me to switch. I said I'd switch when it got a real OS. Enter OS X. On first boot my first thought was, "This is a NeXT with the dock rotated 90º clockwise" I was less wrong about that than I expected.

>I had to use Macs in college. They crashed just as bad as the PCs.

I also used Macs a lot in college, and had the same experience. People who never used pre-Unix MacOS have no idea how unreliable it was. Windows 95 and 98 weren't great, but there was at least some hope of killing an errant application and continuing on. System 7? No hope whatsoever. It didn't help that Mosaic (and Netscape) wasn't very reliable regardless of platform, but pre-Unix MacOS's own failings made things that much worse for using the emerging WWW.

>Enter OS X. On first boot my first thought was, "This is a NeXT with the dock rotated 90º clockwise" I was less wrong about that than I expected.

I also used (and liked) NeXT machines in college, but not nearly as often as the other platforms; by the time I got to them, they had been relegated to running helpdesk-client software.

I first tried out OS X in 2003. I've been using Linux at home since 1995 and had tried every available desktop: CDE, KDE, Gnome, Enlightenment (The horror .. the horror ...), Window Maker/AfterStep, fvwm, and even older ones like Motif and twm. OS X was a revelation.

I still use Linux as a server, but for a Unixlike desktop that actually works and runs a lot of applications, OS X is it. Period.

(I wrote the above on Slashdot ten years ago <https://slashdot.org/comments.pl?sid=2940345&cid=40457103>. I see no need for changes.)

I remember the 90's as the era of instability in desktop computing.

It really was (though I can't speak for the people working on NeXT boxes and Sun Workstations, etc). It wasn't really a matter of if a given computer would become unstable and crash every day, but how many times and how much you would lose. Somehow I still developed a liking for computers, but even with the incredible increase in complexity which works against it, a $30 prepaid Android burner phone today is more stable and reliable (though it isn't more fast and responsive) than any Mac or PC introduced in the 90s.

Like many that lived through (survived?) that era of computing, I still periodically press command-S by reflex, without being consciously aware that I'm doing it.

If you had accounts on the NeXT machines, you wanted to work on your papers there, because it was much less likely to crash and take hours of work with it.

Documentation for the NSObject objective C class : http://www.nextcomputers.org/NeXTfiles/Docs/NeXTStep/3.3/nd/...

Many of the classes in http://www.nextcomputers.org/NeXTfiles/Docs/NeXTStep/3.3/nd/... would likely still be familiar.

The userspace C++ framework for drivers replacing IO Kit, is called DriverKit, which happens to be an homage to the Objective-C framework for writing drivers in NeXTSTEP.

Yes, but we are missing:

- vertical main menu - pop up main menu under right-mouse button - Shelf - Workspace as native app (instead it was re-written in Carbon) - robust support for Services

I'd give my interest in Hell for a way to install Mac OS X so that only Cocoa apps were loaded/available.

And iOS device!

see also Previous, a NeXT Emulator -

HN discussed it https://news.ycombinator.com/item?id=35227600

and the main development happens here https://www.nextcomputers.org/forums/index.php?topic=2642.0

Does this website run on a next box?

No, HN runs on a variant of an emulated LISP Machine.

I think he was talking about https://www.nextcomputers.org, not HN.

Any details of what this is?

It's a semi-joke about LISP.

https://en.wikipedia.org/wiki/Arc_(programming_language)

Unpopular opinion, NeXT hardware was kinda junk. It was a 68030 machine released into direct competition SPARC and MIPS chips that were 3x faster. It had a 2bpp framebuffer (and UI) that would have been really clever and attractive in competition with monochrome workstations of 1986, but frankly when it shipped it looked kinda awful next to the 1MB SVGA cards arriving on the market. At the OS level, Mach was outrageously primitive for a commercial unix (no shared libraries!). And the one genuinely unique and innovative feature (the big MO drive) turned out to be a technological dead end.

The NeXTStep layer was really the only selling point. And in hindsight that was enough. But the hardware itself? Only barely worth remembering.

The original OS absolutely had shared libraries - the whole environment was so RAM-constrained that it was essential. (source - I was part of the early SW eng team). In fact, my memory is that they worked much better than competing systems because of Objective-C's late binding, in the practical case of sharing library code across applications built/shipped at different times on different OS versions. As I recall, C++ based systems couldn't deliver the full sharing on a typical user's system who was never running apps that were all updated for each major and minor release.

Objective-C libraries have such incredibly clean and simple ABIs, it's wonderful.

Mathematica on NeXT ♥

Oh the memories that brings back!

The bright red heart ♥ really stands out on the HN page.

Seriously! I am so used to the tone down presentation, seeing that thing is like, "Oh HELLO!" Got my full attention for long enough to be notable.

Mathematica really stands out. Hahaha.

I was in College at the time, comparing it to the Dec and VaxStations next to it, it held it's own. 'the one genuinely unique feature'?

So Display postscript and WYSIWYG _everywhere_ wasn't a big deal? The developer environment and DSP capabilities were pretty special....the Magnesium was a cool flex and one cable going to the monitor keyboard and mouse...the MO drive was slow, but cool.

Edit to add: And Mathematica. it was CRAZY cool.

> I was in College at the time, comparing it to the Dec and VaxStations next to it, it held it's own

It's interesting to me that this criticism has stayed around so many years in different forms: the iPhone has underpowered RAM compared to Androids, etc etc.

Yet consistently people pick on the overall experience not particular components.

IIRC it was the fastest workstation available for under $5k in 1990 (around 15 mips, I think?). You have to remember what market they thought they were selling to -- it was meant to be a high-end personal workstation, not an industrial machine. Sun and SGI machines started at around $10k and went up from there.

They were sold, among other places, in college bookstores, right beside the Mac and Windows machines. I was a campus consultant and sold a number of them - a lot of my job was hanging out in the bookstore and talking to potential buyers. I have no idea how one went about buying a Sun, but they certainly didn't bother much with individual sales.

So it's competition was the higher end of the Mac line and a bit up from that, really. Turned out there was never much of a market for personal workstations, hence the low sales numbers.

I came into a bit of money in college and decided to buy a Sun workstation.

You are correct - they didn’t know how to fulfill individual sales. The box was delivered to a LTL freight crossdock, and I got a call from a dispatcher to come pick the thing up. I had to drive to the industrial part of town. A bemused guy helped me get the carton down and remove the boxes, then I got to lug thing across the yard.

It was a fun thing to have amongst my nerd friends. I ended up selling it at a nice profit because I was willing to ship it anywhere. The monitor i sold at a loss to a graduate student.

I had another boss at the same company that filled a NeXT cube to capacity with motherboards. For the sake of a good story I will say he had them all running under the same Mach kernel. He described the simple thing he did to get it running, but I have forgotten.

Technology was moving really fast in those days.

Here's how to run multiple NuBus CPU boards in a Cube - it requires some modifications to the backplane: https://wiki.preterhuman.net/NeXTcube_running_68030_and_6804...

The additional boards were netbooted via bootp/tftp, so the additional boards could run the same kernel as the one the hard disk (and/or MO drive) was connected to. Of course, this is a distributed memory machine - not much different than running three diskless Cubes booting from a fourth machine.

There’s a rebuild of a NeXTcube with 4 motherboards being detailed here: https://www.nextcomputers.org/forums/index.php?topic=4950.0

Objective-C shared libraries are a key part of NeXTSTEP.

By the way, the first commercial UNIXes did not have shared libraries.

The NeXT was priced above a PC, but just below a SGI, DEC or Sun workstation. When compared to a top of the line PS/2 model 80 (at $4500 for the tower, and $1000 for the monitor, plus an extra $200 for Windows 386), the NeXT Cube ($6K or so) was a pretty good value because you got a laser printer, the FPU was included and the software library that came with it came with development tools (everyone else charged for them), FrameMaker, Mathmatica and a bunch of other titles that would have been $450 each on the PS/2.

A few data random data points:

PS/2 Model 80 release MSRPs were $6,995, $8,295, and $10,995, depending on the configuration, without monitor, OS, FPU, or support for display resolutions beyond standard VGA[1]. The top model included a 20 MHz CPU, 2 MB RAM, and a 115 MB ESDI hard drive.

NeXT shipped two years later, but its $9,995 MSRP[2] included the OS, application software, additional software, a 17" 1120x832 greyscale monitor, FPU, DSP, and four times the RAM of the top-end Model 80.

IIRC — and I may not, it's been decades — NeXT generally sold at or around MSRP, while other UNIX vendors and IBM typically sold at a considerable discount to large accounts and academia.

To compare with a more "garden-variety" PC, in the same BYTE issue[2] as the NeXT article, Dell was selling its lowest-end 386 for $4,199, with a 25 MHz CPU, 1 MB RAM, monochrome VGA display (640x480, size unspecified), and 40 MB (interface unspecified, probably IDE) hard drive for $6,299, no FPU, OS extra.

This same Dell system with a 150 MB hard drive, SVGA color display (800x600, size unspecified), and 8 MB RAM cost around $7,000 ($5,900 for 150 MB SVGA, +$600 for 4 MB RAM; 8 MB, I presume, would cost another $600×4/(4-1) = $800 or so).

Adding a $500 387/25 FPU (based on ads in the back of the same BYTE[2]) and a $500 Dell UNIX license[3] brings the cost of our Dell system to $8,000, so within 20% or so of NeXT.

Unlike Dell, NeXT also bundled a variety of high-quality developer tools (Allegro Common Lisp and Sybase SQL Server in addition to the expected GNU C/ObjC toolchain, Interface Builder, and NS class libraries), useful application software (Mathematica, WriteNow, Mail.app), and convenient reference works (dictionary, thesaurus, book of quotations, complete works of Shakespeare, product docs).

Finally, NeXT charged $3,695 to upgrade the Cube's internal hard drive from 40 MB to 330 MB, which makes Apple SSD upgrade pricing sound entirely reasonable, as a comparable upgrade from a hypothetical 512 GB to 4 TB NeXT SSD would cost almost $3,000.

[1] https://archive.org/details/byte-magazine-1987-06/page/n134/...

[2] See, e.g., page 178 of

https://vintageapple.org/byte/pdf/199001_Byte_Magazine_Vol_1...

(warning: slow PDF link)

[3] https://www.tech-insider.org/unix/research/1992/0706.html

i don't know about the CPU, but the production quality of the hardware was great. once we had a microsecond poweroutage, the PC powered off, the NeXT machine kept running.

You had 1MB SVGA machines at the time of 68030 ? Can you give some examples ?

The 68030 does look like a curious choice for a machine launched in 1988.

Wikipedia says that they considered the Motorola 88000 but with a source that I've not been able to track down.

> The 68030 does look like a curious choice for a machine launched in 1988.

GP is exaggerating. Spark and MIPS were more expensive machines for a different market NeXT wanted a toe in but was merely straddling; business and education were NeXT's target markets. The 68030 with a math coprocessor was bleeding edge in 1988. Sun released a 20MHz and 33MHz 68030 Sun-3x in 1989, a SunOS (UNIX) workstation.[1] Apple released the 68030 Mac SE/30 (16MHz) in Jan. 1989. There was absolutely nothing wrong with the 68030 in 1988/1989. If anything, NeXT was a little fast out of the gate with the 25MHz 68030 in 1988.

[1] https://en.wikipedia.org/wiki/Sun-3#Sun-3x

They developed a dual-CPU prototype box based on the 88000, circa 1992. It was never released - the company was bought before it advanced past the prototype stage.

They also had a prototype laptop, although I don't know for certain which CPU it was based on. Because the existing battery technology couldn't provide enough juice for reasonable runtime, it was going to be a plug-into-the-wall design.

They gave up on the 88000 the same time Apple did (yes it was considered at Apple too) and is directly related the IBM/Apple PPC partnership and Apple’s insistence that Motorola being a second source for the PPC. It was really Motorola that gave up on the 88000 and not Next.

NeXT wasn't bought until late 1996. That didnt kill the RISC project, what happened is the company dropped all hardware and became software-only (primarily on top of x86 boxes, but some lower-level pieces ran on HP and SPARC).

And spun off their hardware division as Firepower systems and sold it to Canon

Ah, yes, you are correct. Thanks for jogging my memory.

As part of a project code-named "Jaguar", Apple did consider using a Motorola 88K variant as their future RISC-based hardware, but it was short-lived and they moved on to the POWER Architecture. In 1991, Apple, IBM, and Motorola formed the "AIM" alliance with the goal of creating a Common Hardware Reference Platform (CHRP). This led to the PowerPC architecture, which included most of the POWER instructions along with some additions and deletions.

Why was a 68030 a curious choice for a machine launched in 1988?

68020 could run a distributed network OS (Domain OS/Aegis). What was wrong with 68030 ?

Nice! I never 'had' much with NeXT but l love retro projects.

For me the real retro thing is HP-UX 10 with VUE (not CDE!) as I used that in college.

Had a professor in college circa 2000, that had a NEXTstation in his office that he still used everyday. Around this same time, the college purged the UNIX lab of proprietary UNIX boxen (mostly Suns, IIRC, though they kept a few SGIs around in the 3D graphics lab) and replaced them all with Dells running Red Hat :(

I have fond memories of seeing Steve Jobs giving a live demo of NeXTstep at the San Jose convention center. It was a bravado performance. I had a Cube with the laser printer and later a slab. Such an elegant machine for the time.

NeXT's demo really shows just how ahead of the time NeXTSTEP was: https://www.youtube.com/watch?v=rf5o5liZxnA

They literally dont make them like that anymore. Imagine what a computing device / workstation of equivalent function and aesthetics should look like today if progress was monotonic.

Will it burn?

https://simson.net/ref/1993/cubefire.html

Title should read: "NeXT Computers"

HN's annoying algorithm messes with titles. I edited it now.

Strange to find out the site is blocked in India -

Access denied Error code 1020 You do not have access to www.nextcomputers.org.

The site owner may have set restrictions that prevent you from accessing the site.

Error code: 1020 Ray ID: 7c4453141bec5c50 Country: IN Data center: fra03 IP: 122.173.25.62 Timestamp: 2023-05-08 20:06:40 UTC

My friend runs a devshop in California. He was so tired of spam forms, spam emails, and spam calls, that he setup a redirect for India to a page states the business has been closed.

Spam reduced by atleast 50%.

Doesn't seem all that strange considering all the authoritarian speech laws being passed there. I'd be inclined to block India too rather than deal with any potential issues.

NeXT is example 1 of anytime I wonder "have we made ANY progress in desktop".

Linux and Windows desktop experience is at best equivalent to x86 NeXTStep desktop environments (except the OS did have memory leaks).

Especially considering that we are talking at the time a 66 - 100 MHz 486 or the first gen pentiums (again maybe 100-133Mhz), small and short hard drives, maybe 64-128 MB of ram.

Example 2 is BeOS, although I never used BeOS on its era of hardware to personally comment.

However, Jobs tried to make BeOS the basis of OSX, and NeXT was his backup plan. So BeOS must have been pretty compelling.

Jobs had nothing to do with Be. He founded NeXT. Gil Amelio was the Apple CEO when they were working on acquiring BE Inc., which was founded by Jean-Louis Gassée—another former Apple executive. Ironically perhaps, it was reportedly Gassée alerting Apples board to Jobs’ manoeuvring to oust Sculley that saw Jobs fired from Apple.

Nah? Today's laptop lasts all day without a charger, lets you watch and edit 4K video, allows you to order food and have it delivered in 20 minutes or shop for pretty much anything you need online, provides access to detailed VR worlds and advanced AI chatbots. There is a lot of work under the hood that makes it possible. Plus there are lots of new computing devices like cell phones, smart watches, voice assistants and smart TVs with entirely new UI paradigms.

As for original plugged in desktop with a flat monitor, keyboard and mouse, it's relatively easy to experiment with a new window manager under Linux. So if nothing radically different caught on, maybe current design is already optimum for certain tasks like typing in lots of text. After all a text editor window is already similar to a typewriter made in 1868, not everything needs to change all the time. Microsoft learned this lesson the hard way with Windows 8.

Amelio, not Jobs

Reply on news.ycombinator.com