22 ms·
I am still in awe of NeXT's software technology, generally. It was just so carefully and intentionally designed as a coherent whole; one would hope this was whe
by jrochkind1 6y ago
I am still in awe of NeXT's software technology, generally. It was just so carefully and intentionally designed as a coherent whole; one would hope this was where we were going as we got better at architecting software (as individuals, as a field), but disappointingly in retrospect it appears as a kind of high-point, after which we continued to descend into ball-and-twine mediocrity. For Reasons economic and and social that I think people could argue about a lot, but we don't because in part because as a field we don't seem to even agree on what excellence in software architecture/design even means anymore.
But what I want to talk about instead is:
> Like EOF, our database layer that still puts Ruby-on-Rails to shame.
I spent a couple years programming with EOF (the "Enteprise Object Framework", an ORM), and many more recent years programming with ActiveRecord. EOF had a few features that ActiveRecord still doesn't that I miss (like properly functioning multi-table inheritance; and lazy "eager loading" triggered on first access for all associations; Rails 6.1 has a welcome feature to RAISE on n+1 behavior, but why not just lazily trigger the efficient load instead, which is probably no harder to implement? Maybe nobody thought of it, having not used EOF?).
But I wouldn't actually say it still puts ActiveRecord "to shame". ActiveRecord is very similar to EOF in design, by 2020 nearly as mature, with 80-90% of the features.
Yeah, it's striking that ~20 years later we can say AR is mostly as good as EOF haha (and doesn't have anything of note that EOF didn't already have, it hasnt' superceded it in any ways). It's internal architecture isn't quite as elegant. But it really is nearly as good as EOF, it's deficiencies compared to EOF aren't large enough to be particularly shameful, in my experience/opinion, it's in the ballpark!
AR is so similar to EOF that I have always wondered if some of it's designers had experience with EOF.
- deleted 6y ago[deleted]
- anonymouse008 6y agoAnd I'm upset I didn't get an opportunity to properly work with WebObjects. WebObjects with Swift would revolutionize the web - IMHO - it was gone too soon.
- sjg007 6y agoSeems like some demos around 2019 are still available: http://www.alwaysrightinstitute.com/wo-intro/ http://www.alwaysrightinstitute.com/wo-intro/
- grecy 6y agoI coded fulltime in WebObjects from 2006-2008 making webApps in the health care industry. During my Software Engineering degree I learned the difference between a Library and a Framework, but it wasn't until actually using the WebObjects Framework that the light bulb went off in my head. It was a pleasure to work with, and clearly very, VERY well thought out. EOF was great, and every time I made a new NSArray() it brought a smile to my face.
- pjmlp 6y agoIt would hardly do that, in case you aren't aware they were in the genesis of J2EE. > Since the transition of WebObjects to Java in 2000, the functionality of many of Apple's Java Foundation classes is replicated in Sun's own JDK. However, they persist largely for reasons of backwards-compatibility and developers are free to use whichever frameworks they prefer. https://en.wikipedia.org/wiki/WebObjects#Java_compatibility https://en.wikipedia.org/wiki/WebObjects#Java_compatibility
- artificial 6y agoHere's an experiment to that end: https://github.com/SwiftObjects/SwiftObjects https://github.com/SwiftObjects/SwiftObjects
- boris 6y ago> I am still in awe of NeXT's software technology, generally. It was just so carefully and intentionally designed as a coherent whole [...] The closest I got to experience inner workings of NeXT software is observing the boot log of Mac OS (which you can see if you boot it with Qemu/Clover). I haven't seen so many triple exclamation marks in a while. That somehow didn't leave the impression of carefully and intentionally designed software.
- colejohnson66 6y ago“Mac OS” pre-“X” (9.x and prior) or “macOS” post-“X” (11.x and newer)?
- ido 6y agoThey obviously don't mean pre-x as that would have no bearing on NeXT. Probably just collqually using the current name to mean mac os(x) >= 10.0
- colejohnson66 6y agoAh yes. That makes sense. And the rep hit I got shows what happens if you comment when you just woke up
- jrochkind1 6y agoI couldn't say how similar a 2020 MacOS bootlog is at this point to anything that was in NeXT, and wouldn't assume that whatever you're seeing now that you find inelegant was there in NeXTStep 20 years ago or longer. I mean, maybe, but I wouldn't just assume it and judge NeXT for it. ¯\_(ツ)_/¯ In any event, the boot log is not something I had occasion to pay attention to in NeXTStep, I couldn't speak to it.
- nemo 6y agoNeXTStep/OpenStep had a great development environment and was full of innovation but even in the '90s it had old BSD components that were rarely updated and it really wasn't a great unix. Mac OS X has followed that pattern. Also Mach was inherently slow so running OpenStep on x86 hardware was slower than Linux or Windows - in Mac OS X they finally gave up on a pure microkernel and flattened the kernel to reduce the overhead of message passing through the BSD personality layer to Mach. But folks running OpenStep were running it for the RAD development tools and EOF that let you quickly design a UI with a very usable ORM that allowed you to take a desktop app and turn it into a webapp via WebObjects seamlessly. They complained about the *nix layer even then, but the unix layer was adequate and you could compile newer versions of tools you needed then as now.
- jegea 6y agoPersonal experience: Around 2005 I was looking for a platform for a new web app, after some years out of development but having worked extensively with NeXTstep and EOF in the 90s. After watching DHH's video and reading the Rails book, it reminded me so much of my previous experience with NeXT technology that I had no other choice but to go with Rails. The dynamism of Ruby had a lot in common with ObjC's runtime. And reading about ActiveRecord at that time I also had the feeling that its authors had worked with EOF before. All in all, NeXT built great stuff. I still own a NeXTstation Color that I got in 1992 (one of these days I should try to turn it on again). And it's a testament to the quality of that software that some pieces that I'm still running today, like Apple Mail, trace back almost directly to tools I started using back then (NeXTMail).
- jrochkind1 6y agoYep, people don't often comment on how similar ruby and ObjC are, in fundamentals. I think it's because both of them were so influenced by smalltalk, more than ObjC influencing ruby necessarily. But not sure. But I'm still very curious if AR's creators knew EOF, yeah. I haven't found DHH mentioning it; not sure if there might be forgotten other person/people central to original AR architecture. WebObjects itself was nice in many many ways (I think it's encapsulation of form handling is far better than anything anyone's managed in Rails)... but made a fundamental mistake in trying to keep a fundamentally stateful architecture and apply it to the web by putting what was effectively an opaque state ID in every single URL. This was a basically bad design for the web (although also provided for forementioned good encapsulation of form handling. :) ). But yeah, the sense I get in my career is that we spend a lot of time trying to reinvent something that already existed, and getting close to being as good as it... then collectively moving on to the next language/platform and doing it again. With not a lot of progress. Up to and through the 90s, it seemed like there was actual progress in software design and architecture at the high-level, the level of affordances for developers to efficiently create reliable maintainable software, but it seems to me have stalled -- perhaps in favor of huge advances in more low-level stuff, better/different languages/language paradigms, etc.
- wpietri 6y agoAs a former NeRD (NeXT Registered Developer) who started a company that did custom NeXT development, I both strongly agree and strongly disagree. The technology really was great. Their understanding of object orientation was superior. The developer tools were wonderful. The user experience was generally a delight. We could develop custom software in a fraction of the time of people using the tools of the day. NeXT had a true vision of the future. However, what they didn't have was much understanding of economics. The only reason that NeXT wasn't a complete commercial failure was that Apple's board wanted Steve Jobs back. If not, Apple might instead have bought out Be. And if Apple had succeeded in developing their own next-gen OS, both NeXT and Be might be minor footnotes these days. Even prior to the deus ex machina buyout, NeXT was on a slow and steady path to failure. They'd gone from an integrated hardware vendor to an OS-on-other-hardware vendor to a dev-tools-on-other-OSes vendor, and it's not clear that would have worked either. Once the acquisition was announced, they promised to take care of the people who had stuck with them and then did jack. I took a few lessons away from my time with NeXT. 1) Just because I thought something was technically superior didn't mean it was commercially viable. 2) Being too far ahead of the market is worse than being behind it. 3) Never trust a "visionary leader" to look out for you, no matter what he says. He's in it for himself and the vision; the little people are expendable. But you're definitely right that it made using other stuff painful. I stopped doing GUI development altogether rather than shift to Windows, which was incomparably awful by comparison.
- markus_zhang 6y agoThanks for sharing. Can you elaborate a bit why GUI development for NeXT was (and probably is) superior comparing to Windows GUI development (even if we include Borland's effort).
- alblue 6y agoAt the time of NeXT’s heyday in the early ‘90s, most GUI programming was textual. You’d call add(button) and button.text = “Hello World” to build up your GUI, and have to wire up the events from your button to take specific actions. Quite a lot of GUI programming is still like this, even now. What NeXT brought was a GUI editor that allowed you to drag a button from a palette and onto a window (or view). You could then change the text on the button by double clicking on it and renaming the default text. You also got to determine where and how large the button was in relation to the rest of the window. Most GUI builders could do this, so what was special about Interface Builder? Two things stood out. First, you could specify how the button reacted to window resizing. There was a “springs and struts” layout mechanism that allowed you to say which parts were fixed offsets and which were variable. You could also say if the button would resize, and if so, in the X or Y or both directions. The second thing was the ability to connect the button to an action. By Ctrl clicking and dragging, you could wire up the default action to a “selector” — in effect, a virtual method call, on the owner of the button. This owner would be populated at startup, typically the application (controller). So you could have your code with the responder and another team build the UI, and they would join together at runtime. You could also use properties generated by code as well - you could connect the button’s field to an object’s property (aka an outlet) so that changing the code changed the UI. The fact that you could drag and drop connections from UI to code, and from code to UI, as well as building a responsive UI, was really what stood out. This still lives on in Xcode today; IB and PB begat Xcode and IB which begat Xcode. The “nib” format - Next Interface Builder - was a binary format file containing the descriptive state of the Ui and the wiring requirements, which was renamed “xib” when XML became all the rage is the same thing. The fact that IB has been subsumed into Xcode still hides the fact that is what’s happening under the covers. I think it’s important to realise that this was in an age when Windows 3.1 was all the rage, and we had only just got out of 256 colour VGA while Next station had 16 million. Nowadays with everyone doing MVC programming with the web, it doesn’t seem so important. But then there was a time when no one wrote unit tests because it was seen as pointless; but it is from these seeds that ideas become mainstream.
- wwweston 6y agoRE: EOF -- have you ever worked with CoreData, and if so, how would you say it compares to EOF (or ActiveRecord, for that matter)?
- throwaway189262 6y agoJava's Hibernate supports multiple forms of table inheritance and can do lazy loading on all associations. Doesn't stop tons of people from hating it :)
- Rapzid 6y agoThe only ORM I've been impressed with is Entity Framework. AR, not so much.
- yourapostasy 6y agoAre your impressions with the Entity Framework Core multi-platform versions or the Entity Framework 6.0 and earlier, pre-rewrite versions? If it is Entity Framework Core, then what swayed you about it over other ORM's you experienced?