While it's neat to be able to run the actual OS, the title as provided from the blog is a bit misleading. Adafruit also did something similar a few days ago with Solaris.
I may be the only one as I see no one else has commented so, but when I read "build your own..." I'm thinking the actual hardware, or compatible. They should call these articles something like "Run XXX OS and software on your existing machine."
In this particular case it seems reasonably fair, because this is recreating what NeXT had become by the end. While they did continue shipping units for a couple years after the pivot, NeXT's focus on building hardware didn't even last half the period between the company's founding and its acquisition by Apple.
Years ago I acquired and refurbished a NeXT cube. They were certainly a distinctive-looking computer for the day, but I don't know that there was anything particularly special bout the hardware that was worth recreating. The software was the interesting bit.
> Years ago I acquired and refurbished a NeXT cube. They were certainly a distinctive-looking computer for the day, but I don't know that there was anything particularly special bout the hardware that was worth recreating. The software was the interesting bit.
A modern computer running the whole thing in emulation is not the same though.
Whereas for example an FPGA implementation, that’s in line with my idea of “build your own NeXT”. Even though someone might say, that’s emulation too. And they’d be correct in a way. But like, do you see what I mean?
>> Years ago I acquired and refurbished a NeXT cube....
> A modern computer running the whole thing in emulation is not the same though.
>> Whereas for example an FPGA implementation, that’s in line with my idea of “build your own NeXT”.
But the OP is not that. IIRC, there were two distinct versions of NeXTSTEP: a 68k version for their custom hardware, and a x86 version for PCs. The OP is setting up VM for the latter (which given its age does not seem like a trivial thing, either).
So if you must have an FPGA version, it would be equally equivalent to have one that simulates a mid-90s IBM clone.
An FPGA would be hardware emulation rather than QEMU which is software emulation. For older systems, am FPGA can get you a lot closer to how an older hardware worked by mimicking the actual timing characteristics or by just straight copying the gates into RTL. It all depends on the goal, you may just want to run the software at the same speed like for games or you might want to just see how fast a softcore Z80 can run VisiCalc. With the development of systems like the RC2014, FPGAs and newer microcontrollers or SoCs have made their way into peripheral cards to allow easy connections to modern day interfaces like SD Cards, Wifi, and even HDMI. It takes almost no effort to connect an ESP8266 to the serial port of an ancient computer and send AT commands to access websites and network fileshares.
Would you consider an "IBM compatible" PC from the late NeXT era that can natively run NeXTSTEP/i486 authentic? Seeing as that's the (one of) the kind of computer that NeXT sold the OS for.
> Whereas for example an FPGA implementation, that’s in line with my idea of “build your own NeXT”. Even though someone might say, that’s emulation too. And they’d be correct in a way. But like, do you see what I mean?
That would be acceptable, as you built a machine that functioned exactly like the original, running the OS on bare metal - not on unrelated hardware under emulation. That would fit my idea of "building" the machine as well.
I've got a NeXTstation, AKA "pizza box," the black m68k workstation hardware. There's really nothing special about it electrically other than an onboard DSP. It's a pretty standard 68040-based computer. The case though... gorgeous. Hard to imagine recreating that.
Agreed though, the headline is a little odd. I was expecting something akin to that guy who designed and fabbed a new logic board for an SE/30. That would've been a feat, especially since those Motorola processors are so hard to come by now.
Wasn't the casing out of magnesia... I always thought if I get one I will be worried it will go down in a blaze on new years eve if somebody touches it with a sparkler. (I have somehow very specific counter factual worries, since I do not own one)
> "This is so NeXT," I told Sally. "Everything works great in the tests, then when you try to make it work for real, in the field, nothing works. They build a computer out of magnesium, and it doesn't even burn!"
Out of all the things I expected to see today, a very detailed description of the conditions required to set an NeXT cube on fire was pretty near the bottom of the list.
Do you happen to know if you can run NeXTStep on vintage Apple hardware or maybe SPARCstations? I have some various IIcx and quadras and sparc 10, 20, etc.
Sparcstation 4, 5, 10 and 20 models (and the Voyager) can run NeXTstep. For the 10 and 20, it depends on the CPU. Sun SuperSPARC modules should work, but Ross HyperSPARC CPUs are not supported. NeXTstep only supports one CPU, additional CPUs are ignored. Later models (UltraSPARC) are not supported, unfortunately there is also no support for earlier SuperSparc Sun 4m (e.g. the LX) or Sun 4c systems.
I have a SparcStation 20 with 512 MB RAM and the 24 bit framebuffer RAM expansion, this is a great machine for NeXTstep.
If you happen to have an hp PA-RISC machine, some models using the PA7100 CPU (e.g. the "Gecko" 712-series) are also supported and are really nice NeXTstep machines.
Vintage Apple hardware does not work with NeXTstep directly, but you can run Rhapsody (essentially NeXTstep for PowerPC with a System 9-like UI) on early G3 Macs.
The Motorola 88k-based NRW (NeXT RISC workstation) was unfortunately canceled when NeXT decided to leave the hardware business...
Just a while ago installed NeXTSTEP on a HP 9000 712/60 for playing around with the original DoomEd. Runs great except for having not found PA-RISC DooM client binaries or sources for recompiling.
The DoomEd source code seems to be available at https://github.com/DrinkyBird/DoomEd and it's Objective C code, so I would expect this to compile on NeXTstep/PA-RISC (but I haven't tried).
If you don't have a compiler set up on the PA-RISC machine, you should be able to cross-compile or generate a fat binary from ProjectBuilder on NeXTstep/intel.
If you want to run NeXTSTEP on a Mac laptop but don't want to run OS X, then run Rhapsody or Mac OS X Server. It's closer, though it has a sort of not-fish-nor-fowl incomplete facsimile of classic Platinum as its interface. The Wally is probably the best choice for this.
omg can't agree more: i sooooo wish i had kept my NeXTstation Color from 1992 just to have its amazing magnesium case. just beautiful mechanical engineering / materials design. also feel that way about my parents' long sold 1969 LawnBoy 2-cycle engine lawn mower, also magnesium, sturdy engineering, and with which i mowed countless lawns as a kid to save money for computer stuff and sports stuff.
The NeXT physical design - well except the terrible mouse abd keyboard - was absolutely glorious. Just wonderful.
Nextstep was also glorious. I supported a lab full of cubes and slabs.
But under the covers, the hardware other than the terrible magnetic optical drive was boring. There was only minimal hardware distinctiveness. The built in Motorola DSP was nice..ish, but the real revolution before and after NeXT was graphics. The non-NextDimension-equipped cubes were utterly pedestrian compared to things like the Amiga (before) and the SGI machines. Not long after the slabs shipped Apple shipped a Mac ii with a TI DSP on a card for accelerated 3D.
I’m a huge next fan but it was all the experience - excruciatingly terrible for the MO cubes to glorious for the color turbo slabs - which defined NeXT.
Well, even the pedestrian NextCube had a "megapixel" display -- 1024x1024 graphics. Even in monochrome, that was pretty impressive for the day. The icons actually looked like what they represented, not abstractions.
Maybe at the Cube's (albeit still very expensive) price-point. But by 1990 SGI had VGX(T) graphics on the market, which could do 24bit color at 1280x1024. It could also clock to early HGTV signals for overlays.
The original MegaPixel Display was a monochrome 17" monitor displaying 4 brightness levels (black, dark gray, light gray and white) in a fixed resolution of 1120 x 832 at 92 DPI (just shy of a true Megapixel at 931,840 total pixels) at 68 Hz
> but when I read "build your own..." I'm thinking the actual hardware, or compatible.
I definitely thought the same thing being it was an Adafruit post and disappointed both times to see it was just a basic howto on running the OS in a VM. Still very useful knowledge if someone wants to play, but kinda can't help think they worded it that way to draw folks in. I was really hoping it was some FPGA or maybe even an MCU running an emulator, but alas, QEMU / Virtualbox is what they used.
Not the ones in NeXT hardware, unfortunately. The '040 only came in PGA and QFP. And although you can still find LC, EC, and Z variants without much difficulty, finding the version that includes both an MMU and an FPU requires meeting strange men in empty parking garages.
The second cube continued to burn, its sides falling into the slag pile that had consumed the first. "You know, we could make it flare up by throwing some water on it," one of the Livermore engineers suggested. It seemed like a good idea to us, so he pulled out a garden hose with a trigger nozzle and doused the fire with a few quick spurts. The water instantly turned to steam. Thick clouds of white smoke bellowed forwards, out of the chamber. We were covered with a fine white powder.
Glad to remember it and see others enjoying the old stories. I, like others, read "Build Your Own NeXT" with an eye opened for "casting magnesium!" rather than "run a VM with a time-honored OS."
Given the recent anniversary, maybe it would be apt to add a vintage looking sticker with red inked "This machine is a server. DO NOT POWER IT DOWN!!"?
The NeXTstep UI has a bunch of neat things about it.
I didn't use it much (way too expensive for a PC, and not considered an engineering workstation), but I did get to play with one in a computer lab a short while. And later I used a bunch of open source window management and utilities on Linux that mimicked aspects of OpenStep.
The NeXTstep look was very legible and understandable, and stylish at the time. Compare to Mac of the time, or the later Win95. (Today you might be bothered by the wide non-autohide scrollbars with the stipple, the font aliasing, or the particular shade of gray. But you might find it more accessible than ad hoc brochure looks in a lot of UX.)
On the scrollbars, note that the buttons for the two arrows are right next to each other, rather than at each end, which made a lot of sense if the user is actually clicking on the buttons to navigate, and might want to change direction.
The hierarchical assemblies of lists in the UI seemed to come from Smalltalk browsers.
The desktop icons weren't just to represent programs that were running, like'd see on X at the time, or later in Windows 95, but are more like both launchers and navigation (and could be other things), and dockable. More like the dock in current Mac OS X, etc. (I thought of NeXTstep when I made my XMonad window manager setup, where I made commands that navigate to a particular kind of window, starting the program if needed, and a modifier key can be held down to create additional instances of some kind of window.)
Note that the Mac's trash can became a more environmentally conscious recycling bin.
I'm sure some people who used the NeXT heavily could point out many other points of interest.
This video is great, though a bit unfair, besides the manipulative cinematic details.
Three minutes in, you know that Sun (he looks IBM) is going to get destroyed, not because of OO like the narrator later asserts, but because the requirements will leverage components that are bundled with NeXT, but not bundled with Sun.
It's worth it to install the developer tools. A few observations:
This is running a mix of older NextStep apps and newer OpenStep apps. For example, there are two text editors: Edit.app, and TextEdit.app. Edit.app is the original NextStep editor circa 1989, and TextEdit is the OpenStep reimplementation circa 1995. You can tell if it's a newer OpenStep app because it draws Windows-style focus rings around the buttons and controls.
OpenStep became Cocoa, so OpenStep code looks very familiar to anyone who's done Objective-C development for Mac or iOS. NextStep code, on the other hand, looks very foreign to modern eyes (There are no NS classes. It's basically just plain C and AppKit classes like Window, Button, View, etc.)
The TextEdit source code is included in the developer examples folder, written by Ali Ozer. Apple would continue to include the latest TextEdit source code with Xcode up until about OS X 10.9, if I remember.
This version of TextEdit is cross platform, so there's plenty of #ifdef WIN32 code.
There's no NSDocumentController, so there's boilerplate in the app controller, like checking if documents need to be saved before quitting, that a modern implementation would no longer need to worry about.
If you're old enough to remember using Xcode 3, prior to the Xcode 4 redesign, you probably found that IDE quite strange and difficult to master (I miss Xcode 3, myself). Xcode 3 was a descendent of the NeXT Project Builder circa 1996. Playing around with the older, and much simpler, Project Builder makes it easier to understand why Xcode 3 worked the way it did.
Back in about 2000 I managed to get my hands on twelve free NeXTcubes that a tech company was throwing out. I was over eager with my generosity handing them out to the local geek community, and before I realized what I'd done, I didn't have one left for myself. Always regretted that, as they're very cool machines even just sitting on the shelf.
I do still have stacks of NeXTStep CDs sitting in a closet though. I used one of the Intel version ones a couple years ago to install a copy on VirtualBox like this guide is showing. Fun to screw around with it, brought back fond memories of my days in school using an original NeXTstation.
I let a NeXT cube through my hands too, and regret it as well. In high school I guess I was the teacher's pet in my electronics class, and we regularly got old computers and parts as donations. I helped the teacher get a classroom's worth of PCs up and running as a network so he let me have the oddball donated NeXT cube that was just gathering dust. Then in college I traded it to another geek for an Xbox and a bunch of games. Seemed like an even enough trade at the time although now I wouldn't mind having that lovely magnesium cube around.
At the company I once worked for I used a NeXTcube to demo a co-processor board built from VHSIC Phase II chips. The cube's size and form factor allowed for a nice sized board to be plugged into the backplane. And the graphics of the NeXT were pretty advanced for the time. The co-processor board ran a missile tracking algorithm on canned data and the NeXT painted a nice real-time graphic of the tracking. It made for a really cool demo.
Steve Jobs actually paid a visit. When he saw the demo he said "That isn't what we had in mind." We thought he was kind of thick, that he didn't get it that when you have a cool product then users are gonna user and figure out all kinds of different things to do with it. Later it became clear that he was all about controlling the user experience, so seeing what we did was very contrary to his way of thinking.
What Jobs did was incredible and I absolutely believe he was a visionary. But I hadn’t really considered the trade-off. That he would almost require tunnel vision to do what he did. A kind of product design near(far?)-sightedness.
In hindsight this is obvious and probably true of most of us but your anecdote is a great example.
The link title should probably be capitalized the way the company spelt it (NeXT), because otherwise I see this in the article list and I’ve no clue what the article is about (“Next” reads simply as a titlecased adverb).
You know, thinking about it seriously, I’m not sure I agree with this sentiment, as reasonable as it seems on the surface.
I do think the Web Platform makes a pretty bad (foundation for a) UI toolkit, at least judging from the results. I think the amount of awkwardness in JavaScript is just plain unreasonable. I’m also disappointed by how badly the practices of the modern Web accomodate, well, viewing static text and images retrieved over the Internet. Various JavaScript libraries and approaches seem to pass by so fast I get dizzy if I look. (The last point would probably disappear were I to fully immerse myself in Web programming, but I just don’t like it enough for that.)
And yet.
It seems that the people making all these frameworks and producing unjustifiably heavy blobs of JavaScript in order to display a photo... Are gradually encountering and solving, in a practical context and with real-world feedback, a lot of genuinely difficult problems—problems which often have only been considered in an academic context, and then not with an overabundance of results.
It’s not that they go out looking for difficult problems to solve—unlike academics. They frequently don’t even realize the difficulty or the existence of the problem at first. It’s just that they start with a reasonably complete solution for a small problem area, go right to the boundary, and push. Pretty soon the boundary reaches things that were previously only attacked with Grand Generalized Solutions, found hard, and left unsolved. Yet they need them solved, so they push further. The flood of frameworks and best practices occurs because they are iterating.
This process produces warts. I mean, of course it produces warts. It cannot help but produce warts. In a setting that also prizes backwards compatibility, some of those warts survive long enough to become functionally immortal, and so the survivors accumulate even if most warts are eliminated very quickly. Eventually we reach a point where we can only look back at a five-meg Opera executable and weep.
This process also means that some of the new best practices are practically indistinguishable from the old ones. However, that is not in itself a condemnation: a lot of people changing their minds can very well happen a function at a time, a default at a time, even a function name at a time. Some of those changes—maybe even most of those changes—are still noise and passing fads. But they are fads of a specific kind—they are generally not sticky: because iterating is the (social) norm, whole industries and schools of thought don’t get founded around a single supposedly universal solution, and giant edifices of millions of lines and man-centuries of effort don’t get erected around a suboptimal approach (see: XML). As fads go, I’d say these are pretty mild.
So what are some of the hard problems the Web people are solving or found themselves having solved?
Native code generation for dynamic languages. (Tracing JITs pretty much won, from what I can see, yet it seems that nobody expected that, not even the Self people that did much of the foundational work in an academic context before.)
Ergonomics of a fully asynchronous programming environment, up to and including system calls. (Again, cooperative concurrency seems to have pretty much won here, yet it wasn’t that long ago that the BeOS approach of preemption and shared memory seemed a plausible solution for responsive UIs. While people were already doing cooperative threads when the 6502 was the new hotness, my machine has IndexedDB but neither scheduler activations nor transactional memory.)
Model that can represent most of the meaningful organizational semantics in most of the documents. (The problem isn’t inventing a model, the problem is obtaining enough data to converge on the right one. HTML5 is a resounding success in this respect; from what I can see most of the other document preparation or processing systems either had the document author code a bespoke structure, fell back to presentation details, forced everyone to adjust their documents to match the limitations by administrative mandate, were basically unusable, or all of the above.)
Declarative, non-Turing-complete styling that’s still flexible enough to make following the semantic model above feasible and even pleasant. (I like XSLT and dislike most templating, but CSS selectors feel so much more carefully designed than XPath. I suspect having to do efficient and even incremental implementations from the start has something to do with it. I still want a neat mathematical model, like maybe tree transducers, to tell me what I should and shouldn’t include in a styling language.)
Practical, interactive reflowable text layout that can do modestly non-trivial typesetting. (TeX can do some things better but basically can’t do cutouts at all without hardcoding sizes, and it’s a language powerful enough you can basically only execute it. Roff does much less. Everything else either requires babysitting by a human when changing layout widths or would make a typographer from half a millenium ago cringe.)
Resolution independence including on pretty low-resolution devices without fuzziness or glitches and with support for zooming in while preserving in the layout. (The CSS “pixel” is a hack but the approaches in native app ecosystems are absolutely infested with much worse hacks. I wonder how many people on Earth understand the rounding code in a major browser.)
Understandable, even intuitive GUI conventions for (extremely) untrusted applications. (It starts with powerboxes but ends with very subtle tricks like a timer on the “Open” button. Still no petnames for some reason.)
Applications that work offline yet can be used immediately without a user-visible installation step. (Turns out you just had to make the online case the default one and get it wrong a couple of times, and you can give people enough of a framework that they are able to make the major effort required to get it working if they have the motivation.)
Graphical user interfaces that are general enough to do almost anything yet are not a maze of twisty little assignments and repaint calls. (I’ve been watching the progress in FRP since about 2010, and while the Web variations are all pretty kludgey, they’re still a damn sight better than everything I’ve seen atop a native UI toolkit. I get the impression XAML might be a contender but haven’t been able to find a description of how it deals with the difficult stuff; it’s also purely presentational from what I understand.)
Each of these purported solutions has flaws and can be disputed, and I’m sure people can point me to prior work that’s more principled or does some aspects better (please do!). My point is that all of the questions are very difficult, mostly unrelated to the Web’s natural monopoly position, and yet for every one of them the Web ecosystem approach of dumb but dauntless iteration has done the state of the art a lot of good.
Back in 1989, I slept on Tom Rokicki's couch while I attended that year's TUG meeting at Stanford and I got to play with the NeXT that Tom was given to develop TeX for NeXT.¹ It was an amazing machine, especially given the era. The optical disk was slow by modern standards but seemed quite responsive back then and the system was just mind-blowing.
1. I'm not sure if this was pre- or post-release of NeXTTeX
I non-sarcastically switched to Window Maker (https://www.windowmaker.org/) on my main desktop for a little while out of curiosity and was very impressed by the experience. I even installed GNUStep and made a crappy little GUI for an old software renderer I had with the Project Center IDE (http://www.gnustep.org/experience/ProjectCenter.html) which is surprisingly powerful and full of features.
Sure, it was all old and ugly by today's standards, and a big step backwards overall from the Plasma desktop I was used to, but it felt really good to use.
The whole GNUStep ecosystem is crazy impressive too, and idk the history around it, but I assume interest for it died off a long time ago. Which is a shame, because having that development environment on a modern (free as in freedom) desktop would be awesome. Objective-C gets a lot of hate, but IMO it's the better answer to a C successor than C++ was, as it's literally just "C with classes" and none of that other bloat.
But apparently development for GNUStep is still alive (last stable release was ~2 months ago), so maybe there is still hope that it will take off one day!
I switched to WM for a year or so at work and became very comfortable with its way of doing things. It reminds me of the parts I liked of early Mac OS X. The main thing I wished for was a miller columns file manager like in NeXTStep or OS X. I briefly contemplated trying to write my own, but my Objective-C knowledge is minimal and very rusty.
Unfortunately I changed positions and needed a DE that other people could use without getting confused, so I switched to Mate and made it act like Windows 10.
I used Window Maker back in the 90s, and now that I’ve gotten back into Linux on Pi and other hardware, I use it again as my preferred desktop (usually on DietPi). It’s just fast, clean, and easy to configure, as well as port or copy the configuration wholesale.
Ran Windowmaker for a long time on my laptop in the early and mid 00s, on Gentoo. It's entirely fine when you're not going to be able to run more than 3-4 things at a time anyway, and manage all your system stuff like wifi from the command line, because the GUI tools are unreliable or absent. Very light, and tiny on disk.
Eventually switched to XFCE near the end of my time with Gentoo, and kept that when I changed distro to Ubuntu.
Awesome! I ran WindowMaker religiously back in the late 90s and early 2000s. I have very fond memories of how elegant and snappy it was compared to other popular window managers & desktop environments of the time.
> Objective-C gets a lot of hate, but IMO it's the better answer to a C successor than C++ was, as it's literally just "C with classes" and none of that other bloat.
The hate for the amount of @, [ and ] I have to type, specially in non-US layouts is deserved.
i used window maker too. it was actually after i had a chance to work with the real NeXTstep interface, that i started to get disappointed, because as nice as window maker looks, it is not NeXTstep and the quirks and differences in behavior were just irritating.
Apple failed miserably by not only not choosing the NeXT interface (which was a joy to work with), they kept the outline of the Classic Mac OS interface while getting rid of the good stuff (spatial Finder, etc.).
but they did choose the NeXT interface. not so much visually, but having worked with the original NeXTstep, OpenStep, very early and later versions of OS X and also various linux GUIs and windows, i have to say that at least the early versions of OS X were quite faithful renditions of the NeXTstep GUI. all the pieces of functionality were recognizeable, and the interface was just as comfortable to work with.
Spatial Finder was the ultimate example of "It just works" from Macs in the past. Unless you knew what it was doing (always opening folders in the same place), it was something that would be hard to articulate as an advantage over other operating systems.
The tradeoff against that of course was that you could not open the same folder in two different windows. With OS X, Finder implemented Miller Columns[0] (as taken from NextStep), so that ended spatial Finder, since windows could no longer be associated with particular folders.
Personally, I'm a huge fan of Miller Columns as I find the easy hierarchy great as part of the "operating system is the dev environment" approach, but if I worked on more chaotic art projects perhaps I'd like spatial finder more. Either way I use Windows now and most of the alternative file managers don't seem to integrate into the OS well, so I get neither lol
It presents the contents of your disk in a manner congruent to how the human brain deals with physical objects: each file or folder can be found in exactly one place, and its on-screen location remains the same unless changed, just like real objects.
Apple was the only computer company taking advantage of human psychology in such a deep way to make computers easier to use. To some extent they still are, but for decades the Macintosh was pretty much the only computer truly approachable by normies. Mac OS X compromises that approachability in a few fundamental ways (and it's getting worse with the iOS-ization of everything).
iOS did something a little similar through iOS6, with folders having a kind of visual physicality—tapping a folder would "slide" the screen "apart" to reveal it underneath, leaving a clear way out (tap any part of the outer Home Screen, which is still visible at the top and bottom) and making the folders feel like a place, with dimension and location. The down-side was that they were limited to only a few content apps, since scrolling would have ruined the whole effect. Then, iOS7 ditched the whole thing for more-traditional folders (if you've watched the quite-computer-"illiterate" use computers, you know this means they're always gonna feel lost when using folders, now—iOS6 and earlier was the only OS+platform I've ever seen that I'd enthusiastically recommend to my approaching-100 grandma, and expect that she'd do kinda OK at using it unassisted, maybe after some light config of the a11y features).
7 broke a bunch of other excellently-discoverable stuff. The replacement for the unlock slider was especially far into obviously-a-large-step-backwards territory.
Lots of true-blue Mac partisans were crazy salty about the loss of the spatial finder, but I never gave a damn.
I want my file-browsing window to maintain a consistent presentation as I navigate. I don’t need each folder to open another window; that makes me crazy, and was one of the things I hated about OS 9 when I moved to the Mac in the late 90s. To me, the shifts under OS X — mostly, the unixy (BSD-y) underpinnings but also changes like the abandonment of the spatial Finder — made it WAY better.
Yeah - that was the thing. To traditional mac users, the finder wasn't a file-browser, full stop. It was a document viewer. Each folder was a document.
What would have been really nice would have been to get a clear, visually-distinct instance of both; to get a really clear "this is a file browser" tool in the finder, and a really clear "this is a folder" tool in the finder.
They're both really useful tools to have - what was awful wasn't gaining a file browser, but was how they mixed file browsing and folder viewing into this awful pea-soup thing that damaged a bunch of the value points of both tools.
I really like having a file browser, but there's a LOT of value to having something that treats folders as individual, stateful documents.
This is an oversimplification. Unix trains people to think in terms of requiring deep directory hierarchies because the Unix implementation cannot exist without them (I'd argue some of this is due to historical cruft becoming enshrined over the decades). The OS X Finder never managed to bridge the gap between the elegance of the old Finder and the raw utility of the NeXT browser interface.
Something else, anecdotally: NeXT people never used the workspace to actually do anything. They always went to the command line to copy/move files and do other file management things. My takeaway was that the workspace was mainly a proof of concept.
The spatial finder was really 2-3 promises:
• Every time you opened a given folder, it always opened in the same, physical place on the screen. Same size, same spot, same view options. Always.
• Only one instance of a folder could be open at once. If you tried to open more than one copy, it would bring the previous one to the front, instead.
• the act of opening a folder would always consistently draw an animation zooming from the icon you'd double-clicked on, to the final open copy of the folder.
Of these 3 promises, the first one was the insanely-great, "magical" one. It ends up tapping into a really powerful aspect of human memory. It has to be absolutely consistent on the OSes part to work (nobody can EVER move your cheese), but if it is consistent like that, then it feels like it unlocks a weird superpower, because you can always find things instantly based on where they are, physically. It's like going from O(log(n)) to find something to just O(1).
It's like having a "cluttered" (but personal) toolshed, where nobody else would have moved anything around. If you have that guarantee, you don't need to waste time "searching" for something, because you know exactly where you put it when you left it there.
Humans for some reason all have extremely good memories on this front; some are better than others, and there's probably some "learning differences" science on this, but as far as I can tell the floor for this capability is really, really high. Even those of us who are "bad" at this are really, really good.
--
The second item, "only one instance open" is the one that had genuine downsides. Opening multiple views of the same document is a very useful paradigm, which I do all the time in code editors, and in photoshop.
Something that could have been a great compromise, which I think apple really dropped the ball on, would have been having a much stronger separation between two concepts, that in OS X are (practically speaking) really blurry/similar: a "folder view", and a "file browser".
A folder view would have retained all the "spatial finder" behaviors, but a file browser would have looked dramatically different, and allowed you to have all the benefits of opening multiple document views, without the confusion.
The problem with multiple "actual folder view"s being open is you never can tell which one is the master copy for setting the position/view-settings/size. One of them is, but the OS doesn't give an indication. So it really screws with that positional memory thing - you'll have one on the right side of the screen, and have another on the left side, and your brain will "pin" both of those in your memory, but when you go looking for the one that was ephemeral, you can't find it, because the one that got stored was the other one.
It very much resembles early TWM / Solaris / Athena based GUIs. They still exist! You can install TWM. I've used MWM since the late 80's* (mostly on AIX for about a decade), and am glad it is still easily installable on Ubuntu 20.04
That's the cool thing about Linux, you don't NEED your GUI to be a noisy nightmare (looking at you KDE). All my menus are context mouse menus. I don't do start menus, 1 level deep, with fewer than ~8 items, otherwise i'm using CLI or launching it via Xterm. Of course, apps are still at liberty to look like crap!
BeOS looks awesome, and it certainly would have made a great successor to MacOS, but unfortunately it didn't even reach as many people as NeXTstep did.
I am hoping that Haiku keeps up its pace and becomes a viable alternative
The keyboards really are nice to type on. Though for the life of me I can't figure out why, on a UNIX system, they put the pipe character in such a weird place. It's above the keypad.
If you (the general you, not you specifically, since you probably already know this) get your hands on a NeXT keyboard and want to use it with a modern system, Adafruit has a guide here for building a USB adapter with an Arduino: https://learn.adafruit.com/usb-next-keyboard-with-arduino-mi...
On US-English keyboards, the pipe character is in the regular spot, but the back-quote/tilde key is on the number pad instead of its usual location above the Tab key. The Escape key is above Tab (Because there are no function keys).
But it wasn't a problem, because if you typed "Shift+Escape" it would translate to the tilde character, just as if the back-quote/tilde key was in its proper location.
One was the MO; that was dire and terrible and they should never have shipped it. This was very rapidly fixed by adding HDs to every system as soon as we realized what boat anchors the MO-only systems were.
The second was the poor HW quality of the mice and keyboards. They simply broke a lot more frequently than the PCs, Suns (even the cheap pink/grey ones that I've forgotten the name of), SGIs and Dec systems.
The last was that we were an AFS university and the NeXT systems, if you accidentally browsed the AFS top level directory, would hang the browser for at least 30 minutes. Super unpleasant if you needed to head to class since a locking screen saver did not kick in even after the browser recovered. As a side effect, we'd have students yanking the power cord which itself was not always something that the HD slabs recovered from.
That said, I loved them, everything about them, and there has never been anything like that. The Sun-vs-NeXT thing was night and day.
I never bought from Black Hole (Rob Blessin) directly since shipping to Europe is rather expensive, but Rob is a long-term NeXT supporter and also very active on the nextcomputers.org forums - so I would recommend getting in touch with him if you are interested in buying a system.
I think his company is mostly a single-person operation, so I would expect response times sometimes a bit longer than what you might be used from larger companies.
Could the title of this entry be altered to include the full article title including the extremely relevant "[...] with a virtual machine" so as to be less misleading and click-baity?
yeah, I was expecting some hardware hacking of some sort, not setting up a regular virtual machine in a PC. At least they documented the process of building an ADB to USB adapter for the keyboard/mouse.
Take care, though. The original NeXT keyboard and mouse were not using ADB, but a proprietary (and a bit strange) protocol. The keyboard and mouse controller were actually contained in the monitor (for mono systems) or soundbox (for color systems), the NeXT communicated with the processor in the soundbox using a high speed serial protocol that also transmitted audio data. Only the later Turbo Cubes and Stations used ADB.
I bought a NeXTStation through the University program back in '92. That was the low end model, 8MB RAM, 120MB disk. The disk was too small for the development tools, but it was quickly swapped out for a 400MB and I bumped it up to 20MB. 25Mhz '040, SCSI, 10BaseT (!!), plus the crazy framebuffer based printer that used a video interface. (I have one of those too.)
It's at my friend house now, he just managed to revive it after assorted false starts over the past few months. I have yet to actually see it running myself.
In hindsight, one of the things that made the NeXT, or more specifically, NeXTSTEP amazing, was what it could do given the hardware of the day.
The stand out was Display PostScript. What an absolute marvel of the time. That it could actually perform. Here was a system with a full boat windowing and GUI system, built on the full PS rendering model (INCLUDING the alpha channel), in real time, with a few MB of memory and a 25MHz '040. When you dragged a window. You dragged the window. The entire thing, not just a frame. That was a big deal.
I remember the heresy of people posting "rich" news poss to USENET using the whatever the news application was called in the day. This was before there was a MIME standard, just making stuff up everyday.
I think it would be a marvel to have the original source code ported, straight up, "bugs and all" to modern hardware.
Specifically thinking having NS ported to an off the shelf Raspberry Pi. I don't know if we have anything like that today. Creeping features have exploded...everything on a modern *NIX system. I don't think you can run XClock in 8MB of RAM today.
If NS was usable (I won't say it was fast, my memory doesn't go back that far, and after seeing several vintage machines, none of them were "fast", we just didn't know any better), just imagine how usable it would be on something even as small as a modern Raspberry Pi.
But it was a great machine. It handled my USENET and email feed over my 2400 baud Hayes Smartmodem with aplomb.
> NS was definitely more than "usable", it seemed very snappy at the time.
Indeed, it's just that I've become quite jaded when it comes to computer speeds. All of the older machines were "fast" or better back in the day, but we only had other current machines to compare them too.
My friend, who has my NeXT, also has a G4 Cube. That thing waking up from "sleep" is GLACIAL. It just takes forever. I'm sure it was snappy and "fast" at its time. Today, perhaps, not so much.
But, still, it was a great testament to what could be done on such limited hardware.
I did this a few days ago and was really surprised by the copying and untaring not having progress bars. I know this thing is old, but as it is heralded so often as a really great system, this little detail struck me as really user unfriendly and I would have not expected to find something like this there.
I have to admit, setting this up was kind of a pain in general and I am not sure if it is worth the trouble.
Maybe someone can give some examples while it might be? I personally wanted to take a look at Lotus Improv, but could after setting it all up not find a version for intel. I guess there never was one?
There never was a lotus improv for non NeXT hardware. Lotus killed NeXT improv basically lay immediately after it came out.
What happened was lighthouse design came in and built an exact clone of improv called quantrix. The manuals were interchangeable - I’m actually learning them now.
I bought a boxed copy of improv and quantrix manuals.
It is /excellent/ we really have a lot of excellent ideas in our computing past.
If you want a copy of the lighthouse apps (they gave away licenses when sun bought them in 1996 or so.
) check out next computers.org
They have a file section.
So this gets complicated so
Improv 1.0 is available on m68k next hw.
Improv 2.0 was only available for windows x86.
Lighthouse design quantrix for nextstep is available on m68k, x86, hp-parisc and sun hardware.
Then there’s an offshoot of lighthouse design quantrix which is quantrix modeller written in Java and available for windows and Mac. It costs $2500/year.
I’m learning improv on m68k and quantrix(the manuals interchange freely) on m68k/x86.
I have it along with manuals and the update. I used it for years for various personal finance tracking (runs in a Windows XP VM on macOS). This is Lotus Improv, nothing to do with Quantix.
Been using computers since DOS 6. "App" was very rarely used, to the point that if you'd ask me to list names for the concept of a computer program I'd probably not have come up with it, before iOS, in my experience.
People called applications apps long before the iPhone or NeXT. The term "killer app" was coined in the early 1980s to mean an application that was so must-have it would sell computers on its own. Typically this was a spreadsheet; VisiCalc was the Apple II's killer app, and Lotus 1-2-3 was the killer app for the IBM PC.
The word "app" existed, sure. But as the "Trends" chart shows it because prominent as the preferred name for executables with smartphones in general (meaning, "small application"[0]), and the iPhone in particular. From my memory that was causation, but I grant that it could've been correlation.
Actually the first use of the term "killer application" (not even "killer app" yet) in print was 1988, in PC Week. See Wikipedia. NeXT's first computers were 1987.
It was in common use with the Digital Research GEM desktop in the mid '80s (which used a .app suffix for applications), but was not particularly unique to GEM.
For the file extension. I did a quick search and all of the GEM ads and articles I could find call them "applications", "software applications", and even "executables".
I actually followed this guide the other day. Pretty neat to be able to run NeXTSTEP and play around with all the old apps. Be warned though, as the article says, the mouse is very difficult to use/control due to the drivers and differences between modern mice and the mice of the time.
Ive been meaning to try out the MAME version that the MAME devs added a few years ago. Not sure the speed is there but that could have changed, have not followed it too closely. Think they also added SGI Iris so you can say 'hey I know this'.
In 1995, my university had an entire lab of NeXT stations and almost nobody ever used them. Everything about NeXT was amazing, from the hardware specs to the user interface design and forward-thinking industrial design.
Thats cool but please don't take me wrong when I say VMs are no fun. Perhaps some hardware exists that is so bog simple but yet relatively performant and is available from the shelves could run this on bare metal.
I heard a few years ago that Intel Atoms are basically supercharged 486s.
i bought one of these used back when i was in high school. at the time mono 040 slabs could be had for a few hundred dollars. without a doubt, the coolest thing about it was the hardware. oversized flat screen monitors, 2.88mb disk drives, onboard mc56k dsp.
the audio output hardware only operated at 22khz when in stereo, if i recall correctly... however, the presence of the mc56k dsp made realtime resampling of any stream possible without burdening the mc68040 cpu.
perhaps the most interesting component of the next hardware was the "geekport" which was some oddball connector, like a db-19 or something that was a mix of ttl digital lines and analog in/out attached to a/d and d/a that were convenient to the dsp.
I think with the geekport that you might be getting mixed up with the BeBox. "The BeBox aimed to be the ultimate multimedia workstation. It had dual PowerPC CPUs and tons of I/O options including four MIDI ports, multiple sound ports, and the "GeekPort", a 37-pin connector that had power plus digital and analog I/O with a built-in ADC and DAC. Less than 2000 BeBoxes were sold so it's very rare to see one today."
so apparently it was a db-15. i think the dac lived in the monitor, and devices that connected were things like modems and voicemail units. line level audio could be noisy so i wonder if it was just 8 bits of data (or more) and a few control pins that were attached directly to the m56k... i think the native width was 24 bits...
Any use for this now? I would not mind however to have a VM of a single computer i used since 1990 (mind you i skipped windows from 98 til 10) so it would mostly VM for mac & linux)
Early qemu versions had problems with the NeXTstep PS/2 mouse drivers. I created some patches for ancient qemu versions (0.8 and 0.9 in 2005...) to emulate a Microsoft bus mouse, which worked well with NeXTstep (https://github.com/michaelengel/qemuNextSTEPpatches).
I haven't tried running NeXTstep in qemu recently, but I suspect it might simply work today.
The Previous emulator for "real" black 68k-based hardware that is mentioned briefly in the article is actually much more fun and also allows you to run 68k-only software such as Lotus Improv - http://previous.unixdude.net
Hello Hacker Community: I'm not sure exactly what I've stumbled into actually pointed at but I'm still reselling NeXT Hardware after 28 years. My first day working for Alembic Systems selling NeXT Hardware, software and 3rd party products, NeXT shut down their hardware production line and layed off 400 people. So it began ..... what a long strange trip its been . I see my reputation proceeds me and I have a good one there and love my job.
I am a one man shop these days for the most part and well you can see hundreds of NeXT projects I've worked on at youtube.com/robblessin ,
I'm compmuterpowwow on eBay and blackholeinc.com is my perpetual disaster of a website.
When I started the website it was basically a very tiny web , as Sir Tim Berners Lee is one of my customers, I repaired his NeXT cube https://www.forbes.com/sites/danielnyegriffiths/2012/08/10/s... , a lot of war stories fairly sure between NeXT, Alembic and incarnations of leading to Black hole , we actually sold stuff on the Web when most people had no clue what it was lol. I we inadvertently invented spam , when we had the bright idea to send demos of the solid Thinking Modeler using NeXT mail to the University of Wisconsin and it replicated itself a whopping 3mb file bringing their 300 baud network down , oops . Not what we intended to have happen , however when the someone with a NeXT actually completed the download and figured out what it was they thought it was cool. Everything before then involved paper cuts stuffing envelopes with brochures, we evolved and set up a website with downloadable software links http://www.blackholeinc.com/catalog/index.shtml .
I saw acomment below on the original optical drives , they were and are crap , I've had them actually catch fire from the laser igniting the dust lol , then they turned the cooling fan around not sure if it was an improvement. It is possible to repair them now .... the hardware improved and NeXT was the first company to distribute software on CDrom hence the Sony 1X drive , first computers with CD Quality sound card and 56001 DSP , you can even boot them up as a Mac running up to version 8.1 .
When I Tunes crashed fortunately I had the web objects software they needed to update it .....
Sorry to crash the party with a rant but I'm mainly at NeXTcomputers.org or NeXT Computer Enthusiasts and have a lot of cool vintage hardware not just NeXT . Apologies for the rant.
