NeXT did that in 1988: https://en.wikipedia.org/wiki/Display_PostScript
https://en.wikipedia.org/wiki/NeWS NeWS was architecturally similar to what is now called AJAX, except that NeWS coherently:
- used PostScript code instead of JavaScript for programming.
- used PostScript graphics instead of DHTML and CSS for rendering.
- used PostScript data instead of XML and JSON for data representation.
What if Sun had open sourced NeWS in the early 90s? Could NCSA or Netscape have used an open source NeWS to build a web browser that renders HTML using NeWS on X11 or Windows? With no need for JavaScript or CSS, just Postscript?
Don Hopkins? Is it plausible that we’ve had 25 years of JavaScript hell because Sun management didn’t open source NeWS? Or were there insurmountable technical obstacles as well?
https://en.wikipedia.org/wiki/LaserWriter#Hardware
>The LaserWriter used the same Canon CX printing engine as the HP LaserJet, and as a consequence early LaserWriters and LaserJets shared the same toner cartridges and paper trays. PostScript is a complete programming language that has to be run in a suitable interpreter and then sent to a software rasterizer program, all inside the printer. To support this, the LaserWriter featured a Motorola 68000 CPU running at 12 MHz, 512 kB of workspace RAM, and a 1 MB frame buffer.
>At introduction, the LaserWriter had the most processing power in Apple's product line—more than the 8 MHz Macintosh. As a result, the LaserWriter was also one of Apple's most expensive offerings. For implementation purposes, the LaserWriter employed a small number of medium-scale-integration Monolithic Memories PALs, and no custom LSI, whereas the LaserJet employed a large number small-scale-integration Texas Instruments 74-Series gates, and one custom LSI. The LaserWriter was, thereby, in the same form factor (for its RIP), able to provide much greater function, and, indeed, much greater performance, all within the very same LBP-CX form factor, although the external packaging was, for marketing purposes, somewhat different.
James Gosling fought very hard for NeWS, but in the end failed to convince Sun to do the right thing. He was optimistic when he talked me into going to Sun to work on NeWS after I'd already given up on it by 1990, saying that Sun had turned over a new leaf, and was soon going to announce their commitment to NeWS:
Date: Tue 6 Mar 1990 08:37:51 PST
From: James Gosling <[email protected]>
Subject: Re: Sun's response to the net
To: Don Hopkins <[email protected]>
In-Reply-To: Don Hopkins's message of Tue, 6 Mar 90 05:03:31 -0500
> When is the message from Sun coming out? Will it be from you, or
> someone else who will be believed?
It'll be from me, and it'll come out today or tomorrow.
> Will it mention the possibility of Sun putting xnews in the public
> domain, or is it too early to say anything about that?
It's too early to say. It looks good so far, but there are still some
possible legal problems that we need to check out.
> How are the changes at Sun related to making xnews free? Is it a
> central point or just a side issue?
It's a pretty central issue.
> I'm afraid that a renewed commitment to NeWS or internal changes at
> Sun just won't mean that much to me or the rest of the world, unless
> Sun does something substantial that will benefit everyone, like making
> xnews free. As long as Sun keeps NeWS proprietary, any effort they put
> into it will just be seen as self serving...
We'll get it out, even if I have to spill some real blood on the floor.
> What do you think of the theory about DEC making unlimited funds
> available for shooting down NeWS? If there's any merit to that, would
> they try to keep the X Consortium from accepting the donation of xnews
> server source code?? I'm sure DEC couldn't do anything to keep Sun
> from donating GNeWS/X11 to the Free Software Foundation, and I know
> FSF would take it. (I suspect DEC would much rather NeWS die a slow
> painful proprietary death, dragging Sun down with it.)
It has been very clear for a long time that DEC explicitly targeted
NeWS as something to be trashed. That was probably the major reason
for giving NeWS such a ridiculously low profile. There were folks at
sun who didn't want to give DEC a bigger target. The folks running the
show now have more guts.
James.
But in the end Sun redefined the meaning of the word "free" by announcing that OpenWindows source code was "Free for $1000": it cost $1000 for the tape media, and nobody was allowed to put it on an FTP server.Here is a link to my flamey-poo on that sensitive topic, followed by the official announcement to which I was reacting. I'll include some choice excerpts, and a couple more links on the topic.
https://www.donhopkins.com/home/archive/NeWS/flame.txt
>I have been following the messages on the network in the aftermath of the OWPS "free for $1000" disaster... The big problem was not the $1000. It was the word "free".
>In short: If you were a slave, what how would you feel if your master announced you could go "free", but he really meant he was selling you down the river for a media cost of only $1000?
>[...] For years, we (customers, software developers, and employees) have been asking Sun to make Open Windows available for free, in such a way that it could be distributed on the X11R4 tape or through other public channels, but that has not happened yet. Our biggest concern is not that we don't have to pay money!! The most important thing is that we can make changes to the source code, and give copies of it to anyone who wants it, using any media or distribution channel. But we can't, so it doesn't matter how cheap it is.
>Package Includes Window System and Toolkits
>MOUNTAIN VIEW, Calif. -- November 13, 1990 -- Sun Microsystems announced today that the source code for its OpenWindows(TM) application development environment will now be available free of charge (cost of media only -- $995). This means that hardware and software developers will now have a cost-effective way to incorporate OpenWindows -- including the easy-to-use OPEN LOOK(R) graphical user interface -- into applications developed or ported to many platforms from different vendors.
>The package includes code for the X11/NeWs(TM) Window System, OPEN LOOK toolkits, and OpenFonts(TM) with its TypeScaler(TM) technology. Before today, only OpenWindows binaries were available from Sun.
>"Offering free source code for the industry's most advanced, comprehensive window environment demonstrates our ongoing commitment to open systems," said Ed Zander, vice president of marketing at Sun.
>[bla bla bla]
>Availability
>OpenWindows source code will be available January 1, 1991 on magnetic tape for $995 (which includes the cost of media and documentation) through Sun distributors. The source license is included at no cost. There are no royalties for distributing applications developed with OpenWindows. Hardware vendors will pay nominal royalties for systems they resell that run the OpenWindows environment.
I left Sun because they asked us to lie to our customers that Sun was going to continue supporting NeWS, but we knew that was not true.
Here's a personal apology and explanation I wrote to one of our customers:
https://www.donhopkins.com/home/archive/NeWS/Explanation.txt
>Knut, I just quit my job at Sun because Sun's managment is living a lie. Their words say they support NeWS, but their actions testify to just the opposite. There are many people in Sun who want quite badly to kill NeWS, and they have been trying to do that while at the same time giving lip service to NeWS, so they don't get fired. McNealy and other top level executives say they support NeWS, and say they will fire anyone who tries to kill it. So everyone pretends to be behind it to keep their job, while continuing to sabotage it. It is a very unpleasant and unfortunate situation.
And we had a lot of internal discussion about how NeWS fit into Sun's window system strategy. We developed a prototype X11 window manager in NeWS, to prove how much better NeWS can handle seamlessly integrated NeWS and X window management much better than X can manage its own windows. The next step we wanted to take was to write a user-extensible HyperCard-like window manager using HyperNeWS/HyperLook. But Sun management wasn't having it. They actually wanted to do the worst-possible upside-down solution and put NeWS applications inside of X-Windows managed by OLWM, precluding the possibility of arbitrarily shaped windows, tabbed windows, pie menus, all stuff we'd been doing for years with NeWS that we'd have to give up in the name of X interoperability, after we'd already proven we had a working better solution with "owm".
https://donhopkins.com/home/archive/NeWS/owm.ps.txt
https://www.donhopkins.com/home/archive/NeWS/sevans.txt
Steve> I could ask you the same question, "If you want NeWS to be a commercial success, why has NeWSTech been so subborn in the sense of resisting trying to fit into the X environment."
Don> That's not the same question. We want NeWS to be a commercial success, but "commercial success" is not a standard defined by the X Consortium. I think OWM can do a beautiful job of fitting the X environment into NeWS. If you find that concept terrifying, then you know how we feel about the inverse, knowing that we will have to give up many goals we designed for and successfully achieved, in order to accomodate a half assed "fallback" solution to satisfy some of our customers who want to run our competitors' software (because we aren't allowed to make our software good enough for them to want to run).
>We have had a great deal of trouble trying to fit into the X environment. It has taken a huge amount of PostScript code to deal with many X interoperability issues ranging from undocumented selection protocols that XView and OLIT can't even agree on, to input focus grabbing kludges to work around OLWM's incorrect focus tracking behavior, to the fullscreen.ps hack to keep X from grabbing the pointer when NeWS is tracking it. Then there are problems we could do nothing about, like the system locking up when OLWM grabs the server (grabbing the pointer after grabbing the server, and not checking the return value). Many of these problems should have been addressed by fixing X programs or the server, but they were not, instead we had to code around them in PostScript when we could.
Window manager flames:
https://www.donhopkins.com/home/catalog/unix-haters/x-window...
Who Should Manage the Windows, X11 or NeWS? This is a discussion of ICCCM Window Management for X11/NeWS. One of the horrible problems of X11/NeWS was window management. The X people wanted to wrap NeWS windows up in X frames (that is, OLWM). The NeWS people wanted to do it the other way around, and prototyped an ICCCM window manager in NeWS (mostly object oriented PostScript, and a tiny bit of C), that wrapped X windows up in NeWS window frames.
Why wrap X windows in NeWS frames? Because NeWS is much better at window management than X. On the surface, it was easy to implement lots of cool features. But deeper, NeWS is capable of synchronizing input events much more reliably than X11, so it can manage the input focus perfectly, where asynchronous X11 window managers fall flat on their face by definition.
Our next step (if you'll pardon the allusion) was to use HyperNeWS (renamed HyperLook, a graphical user interface system like HyperCard with PostScript) to implemented a totally customizable X window manager! Some notes about OWM OWM is the "Open Window Manager" we prototyped in NeWS. We enhanced the NeWS window frames so they sported indexing tabs, pie menus, rooms, and a scrolling virtual desktop. Many of our enhancements were separatly developed, and plugged together orthogonally like legos. All NeWS applications could use these fancy frames, and the Open Window Manager wrapped X clients in the same frames that NeWS windows got!
This way, factoring the window frames out as a part of the toolkit, and implementing the X window manager separately, NeWS applications don't have to know a thing about X window management, and X clients can go on doing the same nasty things they've always done, and everybody get the benefits of dynamic extensibility, and a consistent user interface, by using the default window class!
I39L window management complicates pinned menus enormously. TNT menus pin correctly, so that when you push the pin in, the menu window simply stays up on the screen, just like you'd expect. This is not the case with XView or even OLWM. Under an I39L window manager, the Open Look pinned menu metaphor completely breaks down. When you pin an X menu, it dissappears from the screen for an instant, then comes back at a different place, at a different size, with a different look and feel. If you're not running just the right window manager, pinned menus don't even have pins! There is no need for such "ICCCM compliant" behavior with TNT menus. When they're pinned, they can just stay there and manage themselves. But were TNT windows managed by an external I39L window manager, they would have to degenerate to the level of X menus.
Under the OWM solution, pinned TNT menus work correctly, and they inherit their pinned window behavior from ClassPopupWindow, the same class managing pinned X menus. The look and feel is high quality, consistant, maintainable, and intentionally extensible.
If I39L window management has such a negative impact on pinned menus, how else will it impact other parts of the toolkit and applications?
Will it effect popup notices? Since they need keyboard input for the buttons, will they have to play the I39L window management game? How do we get the notice tail (a separate canvas) to line up, if the window manager decides to wrap a frame around the notice window?
It is impossible to know how it will effect TNT applications, because the toolkit was specifically designed to be subclassed and extended in areas that overlap with I39L window management. NeWSRoom and the TNT virtual window manager are examples of simple, interesting extensions to the window class that are in direct conflict with I39L window management. We would be giving up a lot of actual and potential functionality, that we designed the toolkit to support in the first place. We need to redesign the window class for greater flexbility and easier subclassability, but those goals are at odds with I39L window management. The result of a cross of these two opposing goals would be massivly complex and would sacrifice most of the important advantages of the TNT approach. However, the OWM approach to window management, wrapping X windows in instances of the TNT window class, synergizes with extensions to the window classes. As an extreme example, you can make OWM wrap window frames with title tabs that pop up pie menus full of handy window management functions around all your X windows.
There are several other technological advantages of managing X windows internally with NeWS, over managing them externally with X. By an external window manager, I mean one that is in a separate address space as the windows. Relative to the server, all windows are internal, all X "Xlib" and NeWS "wire service" clients are external, and NeWS canvas objects and light weight processes are internal. But an external X window manager is in a different address space must try to manage many shared resources at a distance, an intrinsicly difficult task, imposing limitations on the whole system and unavoidably restricting the user interface possibilities.
The management of arbitrarily shaped windows becomes very complicated under an I39L window manager. In contrast, PizzaTool has a popup pizza preview window, whose shape is a rectangular frame around a round (or semi-circular, depending on your appetite) pizza window, with the space between the inside of the frame and the pizza cut out. It was very easy to implement, by subclassing ClassPopupWindow and overriding the /path method to cut out the inside of the frame and ask the center pizza client to add its shape to the path. When you move or stretch the window, you see a rubber-band preview of the actual shape the window will take when you release the button. The pizza path procedure knows to maintain a 1:1 aspect ratio (no oval pizzas), that centers the round pizza in the frame as you drag the resize corner around. The shape of a TNT window is not simply defined by curves or bitmaps -- it is defined by a method of the window object, which can apply constraints and may depend on the state of other objects in the system, like the size or number of slices of the pizza inside the frame. All this nice interactive feedback is totally trivial to implement with TNT, and is completely impossible with an I39L window manager. And even if an I39L window manager could be programmed to perform such custom feedback, it would still have to grab the server and lock out all other animation in the process, instead of using nondestructive overlays like TNT.
X11 window managers must grab the server in order to animate rubber-band feedback over the screen when resizing and moving windows. This grabbing causes many problems with NeWS synchronous interests, that can be demonstrated by pressing the "Help" key while dragging out a rectangle on the root background. NeWS can do a much better job at managing global resources in the server because it is in the same address space and it has facilities like the overlay plane specifically designed to implement such window management functions, without even grabbing the server. This antisocial server grabbing behavior is just one symptom of a general class of problems with external X window management, including other important issues such as keyboard and colomap focus.
If NeWS alone manages the input focus, it can manage it perfectly. An X window manager alone cannot, because it runs in a foreign address space, and is not in a position to synchronously block the input queue and directly effect the distribution of events the way NeWS is. But even worse is when an X window manager and NeWS both try to manage the input focus at once, which is the situation we are in today. The input focus problem could be solved in several ways: OWM solves the problem elegantly, as PSWM did in the past; OLWM could be made NeWS aware, so that when our own customers run our own external X window manager on our own server that we ship preinstalled on the disks of our own computers, OLWM could download some PostScript and let NeWS handle the focus management the way it was designed.
It's criminally negligent to ship a product that is incapable of keeping the input focus up to date with the cursor position, when you have the technology to do so. Your xtrek has paged the window manager out of core, and the console beeps and you suddenly need to move the cursor into the terminal emulator and type the command to keep the reactor from melting down, but the input focus stays in the xtrek for three seconds while the window manager pages in, but you keep on typing, and the keys slip right through to xtrek, and you accidentally fire off your last photon torpedoe and beam twelve red shirt engineers into deep space!
After reading your "flamey-poo" I'm wondering how much other non-technical, meddlesome corporate baggage would have come along for a ride even if someone somehow could have convinced them to make "free" === "free".
If it was more than none, I have a hard time seeing how a strong enough "View Source" philosophy could have sprouted from it no matter how strong the tech was/is. From what I understand the web started with that philosophy, and it only partially made it out of the battle with copy/paste intact.
The fact that you were apparently already burned out once before this flame tells me that there was a lot of such baggage. Am I in the ball park here?
The hype and corporate bullshit that surrounded Java is a good example of what that corporate baggage would have been like if it had been deployed for NeWS's benefit instead of Java's.
If Sun had put as much energy into promoting and supporting NeWS as they did with Java, we would probably live in a very different world today.
Sun turned a corner when they abandoned their Berkeley hippie BSD roots and got into bed with AT&T / SVR4 / Solaris, and that changed a lot of stuff for the worse, making it a lot harder to do things like give away the source code to X11/NeWS. A lot of people from different companies who used to be Sun's enemies, and who had extremely different philosophies and antithetical approaches to "open software", joined Sun and started influencing and managing its policies and projects. A disastrous example was the Distributed Objects Everywhere project and CORBA fiasco, which was originally the crazy idea of a bunch of people from HP and DEC, Sun's former nemesis's, who then came to Sun and started pushing it into everything, to the detriment of NeWS and other older projects at Sun. Some of the problematic people and armchair architectural astronauts that Sun imported and put in charge of DOE/CORBA, like Steve MacKay and Michael Powell, were worthless corporate bullshitters whose main goals were to establish and maintain a hegemony, and they kept their grandiose plans in their head and never wrote anything down or made any hard decisions or came up with anything concrete, because they didn't want to be pinned down to committing to something, when they were actually in way over their heads. The whole point of the incredibly complex software they finally developed was interoperability with other company's compatible software, but in reality none of it actually worked together. It only talked to itself. SLOWLY.
Since DOE was intended to run everywhere and talk to everything but actually didn't, they should have called DOPE for Distributed Objects Practically Everywhere.
DOPE was a complete failure at its stated mission, and it had ridiculously costly overhead and complexity. When they finally delivered something years behind schedule and lacking crucial promised features, it actually required TWO CDROMs to install. (You'd think they could have distributed a distributed network object system over the network, instead of via CDROM, but nooooo: it was just too big to download.) And in the end, nobody actually used "DOE" or "NEO" for anything consequential. They wasted a spectacular amount of time, energy, money, careers, and good will on that crap.
https://en.wikipedia.org/wiki/Distributed_Objects_Everywhere
https://www.javaworld.com/article/2077168/distributed-object...
And then when Java finally came along, the same meddlesome corporate baggage handlers and armchair architectural astronauts went into overdrive to evangelize and promote the Java Juggernaut. And even more of them flocked in droves to Sun to jump on the Java bandwagon. If it was bad after the invasion of System V / AT&T / HP / DEC minions, things got much worse once the Java zombies started arriving in teaming brain-eating hoards to get their part of the action in response to all the hype. The original Java team was brilliant, and there were some extremely excellent people working on it, but they were totally outnumbered by the dead weight of all the hangers-on who didn't want to work hard to make a struggling company great, but just wanted an easy job at a secure company that was already great.
If Sun had shown the commitment and dedicated the resources to NeWS that they did to DOE and Java, things would be a lot different. And it would have probably also turned out terribly, for all the same reasons.
JWZ said the same kind of thing happened at NetScape, too.
https://tech.slashdot.org/story/05/03/10/146234/mozilla-foun...
>This is starting to sound familiar (Score:4, Interesting) by gothzilla ( 676407 ) on Thursday March 10, 2005 @11:10AM (#11899790)
>I remember reading JWZ's blog back in the Netscape days. I remember one entry in particular where he noted that Netscape had changed. It used to be full of people who wanted to help create a great company. It turned into a place full of people who just wanted to work for a great company. The people who live to help create get replaced by those who want to ride on their coat-tails. This happens when businesses become successful. Everything changes. Like the band that was good friends and partied together every night. They get signed, shit gets serious, and suddenly they're fighting and arguing about things till they break up and go their separate ways.
>From an old post in his blog:
>What is most amazing about this is not the event itself, but rather, what it indicates: Netscape has gone from ``hot young world-changing startup'' to Apple levels of unadulterated uselessness in fewer than four years, and with fewer than 3,000 employees.
>But I guess Netscape has always done everything faster and bigger. Including burning out.
>It's too bad it had to end with a whimper instead of a bang. Netscape used to be something wonderful.
>The thing that hurts about this is that I was here when Netscape was just a bunch of creative people working together to make something great. Now it's a faceless corporation like all other faceless corporations, terrified that it might accidentally offend someone. But yes, all big corporations are like that: it's just that I was here to watch this one fall.
>Perhaps the same fate awaits Mozilla. Hopefully not, but when your product becomes as successful as Mozilla and Firefox have, things do change and change is inevitable. It all comes down to how the people involved with the projects handle the change.
>Mozilla did rise from the ashes of Netscape though. Hopefully some of the original Netscape people are still around to help lead Mozilla in the right direction, using their experience from the crashing and burning of Netscape in the late 90's.
>JWZ's rantings can be found at http://www.jwz.org/gruntle/ [jwz.org]
(Just click on the testicle!)
``I have yet to come across so much self-righteous bullshit as when I gaze upon the massive heap of crap that is the jwz web experience.''
-- an anonymous poster to slashdot.org, 1998.
I'm not saying it always has to end in tragedy: C# and TypeScript turned out beautifully, given the constraints they had to deal with, in spite of the fact that they came from a giant corporate behemoth like Microsoft. (Although I'm sure there's a lot of bullshit going on behind the scenes, the trend is to make them more open and community driven.)
I still wish anything had the features of NeWS. I wish people could currently be able to feel freedom, power, expressiveness of such environments, where you could change the look and behavior of anything on your screen with a couple of lines typed in a REPL.
Even though the browser has been creeping every day towards it, it seems impossible to escape the constriction of it's haphazard evolution. Browsers have all the hard parts of a NeWS server already worked out inside them (but in C/C++ code), but even if you could magically transform it, it seems it would still be horribly constrained by many other layers of cruft.
Here's a handy guide to when to use open source:
- when you're trying to gain mindshare and you're behind
- when closed-source == product death
- when your customers won't purchase from you if you don't
- when it helps you upsell to other more proprietary /
less-open products and services
- when you need it to retain talent and it doesn't
compromise the business
Open source is a business tool, not necessarily an end (though it can be an end too).Not in Display PostScript, perhaps, but NeXT definitely had OOP pervasively; where do you think the modern Apple use of Objective-C came from?
That's why it was such a natural progression for Apple to switch from Display PostScript to Cocoa, which was the moral equivalent of PDF, which is just PostScript without the Turing-complete programming language part.
This was followed by a vision of a window system built on ROFF.
Oh wait. That IS what we have today! Never mind.
https://en.wikipedia.org/wiki/DSSSL
"Sometime in or before 1994, Opera Software began drafting a "DSSSL Lite" specification for the consideration of the World Wide Web Consortium"
https://www.drdobbs.com/a-triumph-of-simplicity-james-clark-...
>A Triumph of Simplicity: James Clark on Markup Languages and XML
>By Eugene Eric Kim, July 01, 2001
>If you peek under the hood of high-profile open-source projects such as Mozilla, Apache, Perl, and Python, you'll find a little program called "expat" handling the XML parsing. If you've ever used the man command on your GNU/Linux distribution, then you've also used groff, the GNU version of the UNIX text formatting application, troff. If you've ever done any work with SGML, from generating documentation from DocBook to building your own SGML applications, you've undoubtedly come across sgmls, SP, and Jade.
>Whether you've heard of him or not (and mostly likely, you haven't), James Clark (below right) has made your life easier. In addition to authoring these and other widely used open-source tools (see http://www.jclark.com/ for a complete list), Clark served as the technical lead of the original W3C XML Working Group and as the editor of the XSLT and XPath recommendations. He recently founded Thai Open Source Software Center ( http://www.thaiopensource.com/ ). His latest project is TREX, an XML schema language. Clark sat down with Eugene Eric Kim to discuss markup languages, the standardization process, and the importance of simplicity.
https://news.ycombinator.com/item?id=16227249
>The mighty programmer James Clark wrote the de-facto reference SGML parser and DSSSL implementation, was technical lead of the XML working group, and also helped design and implement XSLT and XPath (not to mention expat, Trex / RELAX NG, etc)! It was totally flexible and incredibly powerful, but massively complicated, and you had to know scheme, which blew a lot of people's minds. But the major factor that killed SGML and DSSSL was the emergence of HTML, XML and XSLT, which were orders of magnitude simpler.
>James Clark: http://www.jclark.com/ https://en.wikipedia.org/wiki/James_Clark_(programmer)
>There's a wonderful DDJ interview with James Clark called "A Triumph of Simplicity: James Clark on Markup Languages and XML" where he explains how a standard has failed if everyone just uses the reference implementation, because the point of a standard is to be crisp and simple enough that many different implementations can interoperate perfectly.
>A Triumph of Simplicity: James Clark on Markup Languages and XML: http://www.drdobbs.com/a-triumph-of-simplicity-james-clark-o...
>I think it's safe to say that SGML and DSSSL fell short of that sought-after simplicity, and XML and XSLT were the answer to that.
>"The standard has to be sufficiently simple that it makes sense to have multiple implementations." -James Clark
https://news.ycombinator.com/item?id=20384206
>He's not that famous outside of hard core geek circles, but I am a huge fan of James Clark (not the SGI guy, but he's awesome too for different reasons), who wrote the Expat XML parser, Relax/NG XML schema language, and many other widely used standards and bodies of code that drive the Internet.
[...]
>DDJ: You're well known for writing very good reference implementations for SGML and XML Standards. How important is it for these reference implementations to be good implementations as opposed to just something that works?
>JC: Having a reference implementation that's too good can actually be a negative in some ways.
>DDJ: Why is that?
>JC: Well, because it discourages other people from implementing it. If you've got a standard, and you have only one real implementation, then you might as well not have bothered having a standard. You could have just defined the language by its implementation. The point of standards is that you can have multiple implementations, and they can all interoperate.
>You want to make the standard sufficiently easy to implement so that it's not so much work to do an implementation that people are discouraged by the presence of a good reference implementation from doing their own implementation.
>DDJ: Is that necessarily a bad thing? If you have a single implementation that's good enough so that other people don't feel like they have to write another implementation, don't you achieve what you want with a standard in that all implementations — in this case, there's only one of them — work the same?
>JC: For any standard that's really useful, there are different kinds of usage scenarios and different classes of users, and you can't have one implementation that fits all. Take SGML, for example. Sometimes you want a really heavy-weight implementation that does validation and provides lots of information about a document. Sometimes you'd like a much lighter weight implementation that just runs as fast as possible, doesn't validate, and doesn't provide much information about a document apart from elements and attributes and data. But because it's so much work to write an SGML parser, you end up having one SGML parser that supports everything needed for a huge variety of applications, which makes it a lot more complicated. It would be much nicer if you had one SGML parser that is perfect for this application, and another SGML parser that is perfect for this other application. To make that possible, the standard has to be sufficiently simple that it makes sense to have multiple implementations.
Hope something like that will never see the light of day.
And Doom. Definitely Doom.
https://en.wikipedia.org/wiki/ManaGeR
>ManaGeR or MGR was an early windowing system originally designed and developed for Sun computers in 1984 by Stephen A. Uhler, then at Bellcore.
>MGR featured overlapped, asynchronous windows and an applications interface that was both machine and network independent.
>Each MGR window had support for both character terminal operations as well as basic graphics operations. It was controlled by mousing pop-up menus, by keyboard interaction, and by escape sequences written on pseudo-terminals by client software.
>The system was presented at the USENIX Fourth Computer Graphics Workshop in 1987 as "MGR - a Window System for UNIX".[1] The entire MGR source code was posted to the comp.sources.unix Usenet newsgroup, Volume 17, Issue 1, in January 1989.[2]
MGR was the largest posting to ever appear in comp.sources.unix:
https://groups.google.com/forum/#!topic/comp.sources.unix/GG...
Also Chris Torek, Mark Weiser and others developed "Maryland Windows" at the University of Maryland Computer Science Department, based on the Gosling Emacs screen redisplay code and terminal drivers. It was very good over slow modems because it used Emacs's intelligent redisplay algorithm aka "Ultra-hot screen management package" -- the one with the skull and crossbones.
https://www.donhopkins.com/home/code/display.c.txt
Maryland Windows source code:
http://cd.textfiles.com/sourcecode/unix_c/languags/c/mw.tar
https://groups.google.com/forum/#!msg/net.emacs/yXfZGeHJrNY/...
Of course now lots of people just use emacs with shell buffers as a windowing system, inside of something like screen or tmux.
There is an X window manager written entirely in elisp for GNU Emacs, EXWM, that was started in 2015:
https://github.com/ch11ng/exwm
I have been using it exclusively on my machines for the past three years. By far the best computing environment I have used.
In 2018 I stumbled on XWEM, an X window manager in elisp for XEmacs that was developed from 2003 to 2004:
Just think what could have been!
This only works if all the screens are the same size as a sheet of paper.
- Is it necessary that the document should take the whole screen?
- Is it possible to render a PostScript document in different sizes and resolutions?
- Do any people today read PDFs on their screens? If some do, are all their screens the same size as a sheet of paper?
Anyway, that was not the spirit of my comment. I meant, doing design in HTML, CSS, SVG and then working out again, all from the beginning, how to convert the document to a printable version of professional quality, is more work than writing PostScript for both, even if some configuration necessarily differs between screen and print.
This Cedar demonstration video has some great examples of many of these issues. The Tioga text editor was "WYSIMOLWYG": what you see is more or less what you get.
https://www.youtube.com/watch?v=z_dt7NG38V4
Some problems were due to technology and aren't as bad any more. Cedar and NeWS used black-and-white screens and didn't have anti-aliased fonts. CPUs were much slower and memory was much tighter and graphics were not accelerated, so even with color displays (which were usually only 8 bits with a colormap that makes anti-aliasing very difficult), anti-aliased text wasn't practical.
And fonts rendered at screen resolutions have totally different measurements than high resolution printed fonts, so words have different widths and get flowed and wrapped differently, so the formatting is quite different.
NeWS had a "setprintermatch" primitive that makes the font rendering machinery use the official precise printer measurements for fonts, instead of the actual pixel screen measurements. That was useful for the PostScript previewer, and for editors previewing how formatted text will look. (There was a nice port of FrameMaker to NeWS, but I don't remember how its preview features worked.) But text rendered with printer metrics looks terrible and is hard to read, so you wouldn't want to actually edit text like that.
NeWS 1.1 manual, page 146:
http://www.bitsavers.org/pdf/sun/NeWS/NeWS_1.1_Manual_198801...
>setprintermatch: (boolean setprintermatch - ) Sets the current value of the printermatch flag in the graphics state to boolean. When printer matching is enabled text output to the display will be forced to match exactly text output to a printer. The metrics used by the printer will be imposed on the display fonts. This will usually cause displayed text to look bunched up and generally reduce readability. With printer matching disabled, readability will be maximized, but the character metrics for the display will correspond to the printer. See also: currentprintermatch
Windows are resizable, and while text is scalable, you still want to be able to read and edit text in narrow windows, and not waste screen space or get giant text in wide windows. So reflowing text differently for the screen while editing is very useful.
Also, rendering text in a wysiwyg previewer that precisely scales text is slow the first time and uses a lot of memory, because the particular point size of that font must be rendered into the cache, since it can't just round the point size to a whole number that may already be in the cache (like the scalable "jet" NeWS terminal emulator did to avoid blowing the cache). So it's better if the system renders all text in the same restricted set of point sizes, instead of scaling it continuously.
Also it's costly in terms of screen space to edit two columns of text at once, or pages at a time.
It's just ergonomically easier and wastes less screen space to edit formatted text in one continuous non-paginated column, resizable to any window width you want to use at the time, formatted as close as possible to how it will look on the printer, but without the exact same measurements.
And in this day and age, most text that people write is intended to be read in many different media, formats, screen and font sizes, and layouts. Now it's about WYSIWYG editing text and graphics in the way they will appear in a web browser, and those come in all shapes and sizes (thus Chrome Developer Tool's device preview mode).
Now printing text on paper is only an afterthought, something wasteful to be avoided. So fewer people actually need to edit two-column paginated text just like it will appear printed on paper in a journal, or fuss about exact text layout and worry about terrible "rivers" ruining their otherwise perfectly justified paragraphs.
https://en.wikipedia.org/wiki/River_(typography)
https://en.wikipedia.org/wiki/WYSIWYG
WYSIAWYG; what you see is almost what you get, similar to WYSIMOLWYG.
WYSIMOLWYG, what you see is more or less what you get, recognizing that most WYSIWYG implementations are imperfect.
What You See Is What You Get <jargon>
(WYSIWYG) /wiz'ee-wig/ Describes a user interface for a document preparation system under which changes are represented by displaying a more-or-less accurate image of the way the document will finally appear, e.g. when printed. This is in contrast to one that uses more-or-less obscure commands that do not result in immediate visual feedback.
True WYSIWYG in environments supporting multiple fonts or graphics is rarely-attained; there are variants of this term to express real-world manifestations including WYSIAWYG (What You See Is Almost What You Get) and WYSIMOLWYG (What You See Is More or Less What You Get). All these can be mildly derogatory, as they are often used to refer to dumbed-down user-friendly interfaces targeted at non-programmers; a hacker has no fear of obscure commands (compare WYSIAYG). On the other hand, Emacs was one of the very first WYSIWYG editors, replacing (actually, at first overlaying) the extremely obscure, command-based TECO.
See also WIMP.
NeWS used a color cube with only a certain number of grays, and those were only useful for anti-aliasing black text against a white background (or the other way around), and you didn't have a lot of colors to choose from for antialiased color text or against colored backgrounds. It's much easier to render anti-aliased text in 24 bits, or with pure gray scale, since you aren't restricted to an 8 bit color palette, and you can efficiently mathematically blend colors together, instead of looking up rgb values in a colormap, blending to get the ideal desired color, and then searching for the nearest color to each pixel in the colormap (or indexing the color cube for the nearest color) (which won't be very near, and will look flat and washed out without dithering).
Better visually to render the whole image with antialiased text in full 24 bits, then use error diffusion dithering over the entire image at once (to avoid flat washed out regions, and distribute the error over space) to make an 8 bit palletized version, but that's quite slow and memory intensive.
Of course your application (like a monochrome PostScript previewer) could switch in an all-gray ramp colormap for efficiently rendering and beautifully displaying anti-aliased text, but then all the other windows on the screen would be shown in the wrong colormap, and the colormap would flash back and forth when you moved your focus between windows.
This extends to fonts too, since PostScript letters are drawn using the same graphic primitives as other graphs.
Another neat trick that HyperNeWS supported was drawing a shape in its graphical editor and then pasting that shape as the shape of a window...
https://www.youtube.com/watch?v=z_dt7NG38V4
>Eric Bier Demonstrates Cedar. Computer History Museum, Recorded on January 24, 2019.
>This interpretive production was created from archival footage of Eric Bier, PARC research scientist, demonstrating the Cedar integrated environment and programming language on January 24, 2019. Cedar was an evolution of the Mesa environment/language, developed at PARC’s Computer Science Laboratory originally for the Xerox Alto. Mesa was modular and strongly-typed, and influenced the later Modula family of languages. Cedar/Mesa ran on the D-machine successors to the Alto (such as the Dorado) and added features including garbage collection, and was later ported to Sun workstations. Cedar/Mesa’s integrated environment featured a graphical window system and a text editor, Tioga, which could be used for both programming and document preparation, allowing for fonts, styles, and graphics to be embedded in code files. The editor and all its commands were also available everywhere, including on the command console and in text fields. The demo itself is running through a Mac laptop remotely logged into Bier’s Sun workstation at PARC using X Windows. Bier demonstrates the Cedar development environment, Tioga editor, editing commands using three mouse buttons, sophisticated text search features, the command line, and the Gargoyle graphics editor, which was developed as part of Bier’s UC Berkeley Ph.D. dissertation. Bier is joined by Nick Briggs, Chris Jacobi, and Paul McJones.
Here are some notes about that I took:
There were several window systems developed for Cedar: Warren Teitelman developed Docs. Lots of functionality, but slow. Scott McGregor developed Viewers. It was lean and fast, in response to Docs. Michael Plass built the Cedar imager.
The Experimental Programming Environment Research Project looked at different competing projects to decide which to standardize on. Cedar/Mesa came out of that and played a dominant role in the 80's. The Smalltalk people contributed ideas but were (not railroaded but) frustrated.
Cedar had a ubiquitous almost-wysiwyg structured text and code editor called Tioga. It was important in Cedar, because it's everywhere, even the text fields. The terminal window has a stripped down text editor with subset of commands.
Setting the so-called "clipping level" in Tioga (like a folding outliner) goes back to Englebart's NLS. Bill Paxton and Doug Wyatt were NLS people who also worked on Tioga.
Key ideas were applicable in any possible place in both systems. The Alto had small memory, and each program took over the entire system. It was not integrated. Simple little editors for code. Fancier editors for documents. Using the same component everywhere is something Smalltalk was pioneering even on the tiny Alto. When Cedar came along, running on a much bigger more powerful 1 megabyte D-Machines, it pulled together those ideas, and added so much more, including much more advanced graphics, way beyond what the Alto could do.
Tioga could display and edit formatted code with different levels of indentation and formatting. Tioga was not completely WYSIWYG. Print mode shows two columns, but you edit one column. You could get a pretty good idea of what it would look like, but in the early times it did not have smooth fonts. Bitmap fonts measure differently on the printer, so text is necessarily broken and flowed differently. The printer used Interpress, the predecessor of PostScript. You could preview Interpress files in Cedar. (The video shows a demo of both editing a document in Tioga, and previewing the Interpress file that it produced for the printer.)
Recently I wrote about the differences and similarities between Forth and PostScript, and the influences of Evans and Sutherland's "Design System" on John Warnock and Martin Newall's "Jam", then Jam's influence on John Warnock and Charles Geschke's "Interpress", then Interpress's influence on PostScript:
https://news.ycombinator.com/item?id=21968175
>Kragen is right that PostScript is a lot more like Lisp or Smalltalk than Forth, especially when you use Owen Densmore's object oriented PostScript programming system (which NeWS was based on). PostScript is semantically very different and much higher level that Forth, and syntactically similar to Forth but uses totally different names (exch instead of swap, pop instead of drop, etc).
>But its most obvious similarities with Forth are based on generic Computer Science concepts like stacks, which is not something particularly unique to Forth itself, so saying PostScript was influenced by Forth ignores other much more influential languages like Interpress, JaM, and Design System, which directly influenced PostScript and were designed by the same people. Also, PostScript is not threaded like Forth. But it's homoiconic, unlike Forth and Lisp.
https://en.wikipedia.org/wiki/Threaded_code
https://en.wikipedia.org/wiki/Homoiconicity
https://en.wikipedia.org/wiki/Martin_Newell_(computer_scient...
The heavily commented PostScript source code of PizzaTool for NeWS shows Owen's OOP PostScript system in action:
https://donhopkins.com/home/archive/NeWS/pizzatool
PostScript was a direct descendent of and heavily influenced by Xerox PARC's Interpress, by John Warnock and Charles Geschke, which itself was a direct descendent of JaM, which stands for "John and Martin", by John Warnock and Martin Newall. And JaM was a descendent of Evans and Sutherland's Design System, by John Warnock and John Gaffney.
https://en.wikipedia.org/wiki/John_Warnock
http://historyofinformation.com/detail.php?entryid=1213
https://en.wikipedia.org/wiki/Martin_Newell_(computer_scient...
https://en.wikipedia.org/wiki/Charles_Geschke
https://en.wikipedia.org/wiki/Interpress
https://en.wikipedia.org/wiki/Evans_%26_Sutherland
Brian Reid (whose brother is Glenn Reid, author of several books on PostScript from Adobe) wrote up an excellent historical summary in 1985 on the laser-lovers mailing list of the influences and evolution of PostScript.
https://en.wikipedia.org/wiki/Brian_Reid_(computer_scientist...
http://glennreid.blogspot.com/
Here's a post I wrote earlier:
https://news.ycombinator.com/item?id=19874245
>DonHopkins 8 months ago [-]
>Brian Reid wrote about page independence, comparing Interpress' and PostScript's different approaches. Adobe's later voluntary Document Structuring Conventions actually used PostScript comments to make declarations and delimit different parts of the file -- it wasn't actually a part of the PostScript language, while Interpress defined pages as independent so they couldn't possibly affect each other:
https://groups.google.com/forum/#!topic/fa.laser-lovers/H3us...
>By now you can probably see the fundamental philosophical difference between PostScript and Interpress. Interpress takes the stance that the language system must guarantee certain useful properties, while PostScript takes the stance that the language system must provide the user with the means to achieve those properties if he wants them. With very few exceptions, both languages provide the same facilities, but in Interpress the protection mechanisms are mandatory and in PostScript they are optional. Debates over the relative merits of mandatory and optional protection systems have raged for years not only in the programming language community but also among owners of motorcycle helmets. While the Interpress language mandates a particular organization, the PostScript language provides the tools (structuring conventions and SAVE/RESTORE) to duplicate that organization exactly, with all of the attendant benefits. However, the PostScript user need not employ those tools.
There's more interesting discussion about the relationship between PostScript and Forth on c2:
http://wiki.c2.com/?ForthPostscriptRelationship
Here's a lot more stuff I've written about PostScript and Forth (two of my favorite topics!):
https://news.ycombinator.com/item?id=11479364
https://news.ycombinator.com/item?id=13198492
https://news.ycombinator.com/item?id=13705664
https://news.ycombinator.com/item?id=13705739
https://news.ycombinator.com/item?id=18317280
https://news.ycombinator.com/item?id=18692144
https://news.ycombinator.com/item?id=18695275
https://news.ycombinator.com/item?id=18696116
https://news.ycombinator.com/item?id=19873630
Incidentally, the nascent web looked horribly primitive when you already had fairly rich networked hypermedia and missed the significance of the web architecture.
Among other advantages, I can imagine a world where PostScript would be used for building user interfaces: a document in screen and print would look the same, without need for writing conversions like, e.g. HTML+SVG -> PDF when someone needs to somehow print a web form quickly. And perhaps the old principles of typography and the experience in typesetting beautiful books with PostScript could be more easily applied to UI design.