On Sat, Jan 01, 2022 at 09:07:49AM +1000, George Michaelson wrote: I was program committee chair for Linux Expo in 1999 (all that means is I formatted the proceedings into a book). I let people use LaTex but encouraged troff. A few people tried out troff and their reaction was "Wow, that was so easy and groff is really fast!"

The only negative reaction was table of contents complaints, LaTex is 2 pass so it can do them, roff is one pass so you have to fiddle with things. A lot.

On Sat, Jan 01, 2022 at 11:56:05AM +1100, Greg 'groggy' Lehey wrote: I was troff friends with W Richard Stevens, he shared with me a lot of what he did in troff. He did the two pass thing. Nice guy and got as much out of roff that anyone could, all of his books were troff.

TeX badly need an official rewrite in a modern programming language (e.g. Go, Rust, even C). The rewrite should drop support for the .dvi format, and use .pdf instead. It should also make use of modern hardware capabilities and not have any built-in limits to how much memory gets used. These issues are well recognized by the TeX community but with Knuth not willing to be the BDFL, TeX is floundering. (I don't mean any of this as criticism of TeX. It's a truly miraculous program that was created in a different time.) Jon

Well, someone could do what I tried (and failed) to do: make Word produce high quality eqn/tbl/pic/troff source as their internal format.

On Jan 11, 2022, at 3:18 PM, Larry McVoy <lm(a)mcvoy.com> wrote: On Tue, Jan 11, 2022 at 04:48:12PM -0600, Blake McBride wrote: Well, someone could do what I tried (and failed) to do: make Word produce high quality eqn/tbl/pic/troff source as their internal format. There was such a thing for TeX, can't remember the name, but my Dad (very computer not savvy) used it to write a book. It was WYSIWYG but spit out TeX.

On Jan 12, 2022, at 8:49 AM, Larry McVoy <lm(a)mcvoy.com> wrote: On Tue, Jan 11, 2022 at 06:12:45PM -0800, Bakul Shah wrote: That's it.

Blake McBride writes: the my in I disagree with your characterization that things like Word are simpler tools. They're way more complex than troff or TeX, both in code and usability.

On 2022-01-11 17:48, Blake McBride wrote (in part): 4. Knuth is getting up in age. Someone will have to take over. Someone has: https://www.latex-project.org/latex3/

It's a double edged sword. TeX looks better but you instantly know it is TeX, it has a particular look. Troff looks just fine to me, and you don't know it is Troff, Word, or what.

Well, with TeX, it's the fonts and the math.

but be overwhelmed by the beauty of its self-consistency. Although after three decades I still can't wrap my head around traps and diversions :-P

An environment is created for the footnote so that it is set at a smaller typeface.

Switch to a previously created footnote environment with a smaller typeface and distinctive line length.

On Tue, Jan 11, 2022 at 1:25 PM Lyndon Nerenberg (VE7TFX/VE6BBM) <lyndon(a)orthanc.ca> wrote: It seems like a lot of people get stuck on the dread trio of traps, diversions, and environments. Some old groff documentation did not, I think, help matters very much by characterizing them as "advanced" and particularly by comparing diversions to pointers in C. I've been rewriting a lot of groff's documentation over the past five years. Here's my attempt to introduce these 3 concepts in the groff(7) page of the forthcoming 1.23 release. Let me know how I can improve it. (I retiterate that it's just an introduction--there is much more detail about all three later in the page and in groff's Texinfo manual, much of which has parallel content to its man pages.) A further few language elements arise as page layouts become more sophisticated and demanding. Environments collect formatting parameters like line length and typeface. A diversion stores formatted output for later use. A trap is a condition on the input or output, tested automatically by the formatter, that is associated with a macro, causing it to be called when that condition is fulfilled. Footnote support often exercises all three of the foregoing features. A simple implementation might work as follows. A pair of macros is defined: one starts a footnote and the other ends it. The author calls the first macro where a footnote marker is desired. The macro establishes a diversion so that the footnote text is collected at the place in the body text where its corresponding marker appears. An environment is created for the footnote so that it is set at a smaller typeface. The footnote text is formatted in the diversion using that environment, but it does not yet appear in the output. The document author calls the footnote end macro, which returns to the previous environment and ends the diversion. Later, after much more body text in the document, a trap, set a small distance above the page bottom, is sprung. The macro called by the trap draws a line across the page and emits the stored diversion. Thus, the footnote is rendered. Regards, Branden Foo On Tue, Jan 11, 2022 at 1:25 PM Lyndon Nerenberg (VE7TFX/VE6BBM) <lyndon(a)orthanc.ca> wrote: > > Dan Cross writes: > > > This is interesting; I've always felt like I could pick out troff pretty > > readily; I agree that TeX has a certain "look" to it (at least by default), > > but I always felt the same about troff as well. > > My guess this is more about how ms(7) does page layout. I can spot > those documents from a mile away :-) > > But older versions of troff can often be spotted by how box corners > don't always line up properly. > > A lot of people get turned off by how troff markup can often look > like line noise. That's true, but if you spend the time to actually > learn the syntax (and it's really not that hard), you can't help > but be overwhelmed by the beauty of its self-consistency. Although > after three decades I still can't wrap my head around traps and > diversions :-P > > --lyndon

On Mon, Jan 10, 2022 at 01:00:15PM -0600, Blake McBride wrote: It's a double edged sword. TeX looks better but you instantly know it is TeX, it has a particular look. Troff looks just fine to me, and you don't know it is Troff, Word, or what.

On Jan 11, 2022, at 5:19 PM, Mary Ann Horton <mah(a)mhorton.net> wrote: I recall attending a TeX lecture by Knuth around 1981. He said he wasn't satisfied with the character layout from other formatting programs, which drove him to write TeX. He illustrated in great detail the kerning and exact placement of the font characters next to each other. I couldn't tell the difference, but clearly it was very important to him. He wanted his documents to look perfect. On 1/10/22 12:33 PM, Larry McVoy wrote: > On Mon, Jan 10, 2022 at 01:00:15PM -0600, Blake McBride wrote: >> 2. Looking at the output, it is my opinion that TeX produces >> better-looking documents. > It's a double edged sword. TeX looks better but you instantly know it is > TeX, it has a particular look. Troff looks just fine to me, and you don't > know it is Troff, Word, or what.

I like that groff and TeX are rock solid and well supported. In fact, I wrote a report generator for a modern web development framework using troff. I use it to develop reports on a routine basis. (kissweb.org) Sadly, however, if word of their existence doesn't get out there, I see them both disappearing in not much longer than a generation. This would be sad indeed.

Greg 'groggy' Lehey writes: Well there is mandoc(1). But as time goes by they just seem to be re-implementing nroff. Of course that *must* be easier than just learning n/troff in the first place :-P I really don't understand this need to throw troff overboard.

For a time perspective, this was 1987, before O'Reilly and Associates was founded. But the macros they (also, primarily, Dale Dougherty) described there are the basis for the macros they used at ORA when I started writing for them in 1993. Some time round the turn of the millennium they then migrated to DocBook, at least for the author interface. I think that they had some magic to then convert it to groff. So I don't think it was "too late"; the DocBook conversion suggests that the authors didn't like groff, though I thought that the conversion was a retrograde step.

The DocBook conversion make it easy for them to generate HTML so that books could be put on CD and browsed with a web browser. I believe that was the main motivation.

On Tue, Jan 11, 2022 at 12:15:43PM -0800, Jon Steinhart wrote: Source code control for the win.

I wrote the GUIs for BitKeeper, I could absolutely give you exactly what you want. Really, what you are describing is our code review system which could done done completely in a web browser but if you needed to hack on things, you cloned it and hacked on it and pushed.

He editted the roff input directly. I gave him a copy of BitKeeper and he used that to check in. Comments were check in comments.

Larry McVoy <lm(a)mcvoy.com> wrote: That book was open sourced ~ 2 decades ago. It was scanned, OCR'ed and converted back into troff. See https://www.oreilly.com/openbook/utp/ and in particular https://github.com/larrykollar/Unix-Text-Processing .

I've never used real troff, just groff. But from the man pages I understood that real troff only generated output for specific typesetters, while groff generated PostScript. Not so?

It's docs. The *roff docs were locked up with the Unix license.

On Tue, Jan 11, 2022 at 10:49 AM Clem Cole <clemc(a)ccc.com> wrote: I read it as s/locked up with/useless without/

I assume you mean s/groff/troff/. There must have been some public access to the documentation like this that allowed James Clark to develop groff in the 1987-91 time frame, though. It's still the *roff shipped with *BSD.

On Tue, Jan 11, 2022 at 1:08 PM Clem Cole <clemc(a)ccc.com> wrote: Not entirely true. There was a preliminary ruling that said that 32V might have lost its copyright protections because it was distributed outside of AT&T without proper copyright notices, as required by the pre-1980 copyright law. This detail was what caused AT&T to settle before it could become finalized (the preliminary ruling said there was a substantial likelihood that this would be the outcome, to be pedantic). To the extent that AT&T had complied with copyright laws requirements, they would retain their copyrights though.

- Ossanna wrote the original nroff in assembly language - He rewrote it in C when the C/A/T was acquired At that time nroff/troff were built from mostly the same sources (as can be seen in the archives).

I have some questions about the earlier history.

As I understand it, in the beginning there was RUNOFF, which I believe originated on CTSS? The CTSS sources contain a RUNOFF program that's made up of ~1100 lines of MAD and ~1300 lines of assembler.

There is certainly a RUNOFF in Multics, written in BCPL (there's a small "outer module transfer vector" program in ALM).

This is where it gets muddy for me; I understand this was roughly ported to unix as `roff` by Ken and that at this point,

formatting was fairly primitive: suitable for hardcopy terminals and line printers, and could do things like center lines and so forth, but nothing fancy (https://www.cs.dartmouth.edu/~doug/reader.pdf)

Ossanna then took over and greatly expanded the capabilities of `roff`, adding macros and traps and making it Turing-complete; this was `nroff`, which grew to become `troff` once the C/A/T typesetter was acquired.

On 1/12/22 13:06, G. Branden Robinson wrote: I used RUNOFF on TOPS-10 in 1971, I think, and eventually also on TENEX and TOPS-20. It probably was available earlier than that. Your history is covering the Unix side, but there is also a pretty robust DEC side. It was available on pretty much all the DEC machines. https://en.wikipedia.org/wiki/TYPSET_and_RUNOFF has some mentions. Dan H.

On Jan 12, 2022, at 4:27 PM, Charles H. Sauer <sauer(a)technologists.com> wrote: I try to avoid inserting non-Unix IBM stuff into TUHS, but since Clem opened the door, ... When I was at Yorktown 1975-77 and 1979-82, using Script (IBM's runoff) on VM/370 was very pleasant from my perspective, for papers, manuals and my three performance modeling books. IIRC when I got there Script output went to Versatecs for draft output and to APS5 for camera ready. By 1979, DCF superseded Script and 6670s superseded Versatecs for draft output. https://en.wikipedia.org/wiki/SCRIPT_(markup) and https://en.wikipedia.org/wiki/IBM_Generalized_Markup_Language seem fair to me.

Hi, Dan, At 2022-01-12T11:33:35-0500, Dan Cross wrote: I've been collecting a detailed narrative history not just of the *roff _programs_ but also of the development on the language in the roff(7) manual page. Below I'll share a current chunk of it that is planned for the next release (groff 1.23). It has been heavily revised since groff 1.22.4. Many of my revisions have been motivated by accounts from this list, from the "history of man pages" (more of a history of troff) at manpages.bsd.lv, and the minnie TUHS archive. This is a detail I hadn't encountered before; instead I've read claims that distorted it into being a solely high-level language project. As I understand it, _this_ RUNOFF is undisputedly Doug McIlroy's. It is hard to find an account of this period that _isn't_ muddy. Claims from Murray Hill luminaries suggest that V0 and V1 Unix roffs were the collective work of Thompson, Ritchie, Ossanna, a fourth person who contributed the hyphenation algorithm (does someone have the name?), and McIlroy, because in Ritchie's words[1], this roff was "transliterated" from Doug's BCPL codebase. Yes. My contributions to groff's roff(7) page attempt to shed more light on this sort of thing. Sadly, at crucial periods sources and even documentation are missing. For example, there is an nroff entry in the Unix V2 manual table of contents, but no man page is present. In other early editions the reader is asked to see Ossanna for documentation, and it seems the corresponding artifacts might be lost to time. Yes. Here's what I have, though it looks better typeset[2]. Corrections from witnesses are warmly welcomed. Name roff - concepts and history of roff typesetting Description The term roff describes a family of document formatting systems known by names like troff, nroff, ditroff, and groff. A roff system consists of an extensible text formatting language and a set of programs for printing and converting to other text formats. Unix-like operating systems often distribute a roff system as a core package. [snip] History Computer-driven document formatting dates back to the 1960s. The roff system itself is intimately connected with the Unix operating system, but its roots go back to the earlier operating systems CTSS and Multics. The predecessor--RUNOFF roff's ancestor RUNOFF was written in the MAD language by Jerry Saltzer to prepare his Ph.D. thesis using the Compatible Time Sharing System (CTSS), a project of the Massachusetts Institute of Technology (MIT). The program is generally referred to in full capitals, both to distinguish it from its many descendants, and because bits were expensive in those days; five- and six-bit character encodings were still in widespread usage, and mixed- case alphabetics seen as a luxury. RUNOFF introduced a syntax of inlining formatting directives amid document text, by beginning a line with a period (an unlikely occurrence in human-readable material) followed by a "control word". Control words with obvious meaning like ".line length n" were supported as well as an abbreviation system; the latter came to overwhelm the former in popular usage and later derivatives of the program. A sample of control words from a RUNOFF manual of December 1966 <http:// web.mit.edu/Saltzer/www/publications/ctss/AH.9.01.html> was documented as follows (with the parameter notation slightly altered). The abbreviations will be familiar to roff veterans. Abbreviation Control word .ad .adjust .bp .begin page .br .break .ce .center .in .indent n .ll .line length n .nf .nofill .pl .paper length n .sp .space [n] In 1965, MIT's Project MAC teamed with Bell Telephone Laboratories and General Electric (GE) to inaugurate the Multics <http://www.multicians.org> project. After a few years, Bell Labs discontinued its participation in Multics, famously prompting the development of Unix. Meanwhile, Saltzer's RUNOFF proved influential, seeing many ports and derivations elsewhere. In 1969, Doug McIlroy wrote one such reimplementation of RUNOFF in the BCPL language for a GE 645 running GECOS at the Bell Labs location in Murray Hill, New Jersey. In its manual, the control commands were termed "requests", their two-letter names were canonical, and the control character was configurable with a .cc request. Other familiar requests emerged at this time; no-adjust (.na), need (.ne), page offset (.po), tab configuration (.ta, though it worked differently), temporary indent (.ti), character translation (.tr), and automatic underlining (.ul; on RUNOFF you had to backspace and underscore in the input yourself). .fi to enable filling of output lines got the name it retains to this day. Unix and roff roff was one of the first Unix programs. McIlroy's runoff was, in Dennis Ritchie's term, "transliterated" from BCPL to DEC PDP-7 assembly language for the fledgling Unix operating system. It saw its name shortened to roff (perhaps under the influence of Ken Thompson), while adding support for automatic hyphenation with .hc and .hy requests; a generalization of line spacing control with the .ls request; and what later roffs would call diversions, with "footnote" requests. This roff indirectly funded operating systems research at Murray Hill, for it was used to prepare patent applications for AT&T to the U.S. government. This arrangement enabled the group to acquire a PDP-11; roff promptly proved equal to the task of typesetting the first edition of the manual for what would later become known as "Unix Version 1", dated November 1971. Output from all of the foregoing programs was limited to line printers and paper terminals such the IBM 2471 (based on the Selectric line of typewriters) and the Teletype Corporation Model 37. Proportionally-spaced type was unknown. New roff and Typesetter roff The first years of Unix were spent in rapid evolution. The practicalities of preparing standardized documents like patent applications (and Unix manual pages), combined with McIlroy's enthusiasm for macro languages, perhaps created an irresistible pressure to make roff extensible. Joe Ossanna's nroff, literally a "new roff", was the outlet for this pressure. By the time of Unix Version 3 (February 1973)--and still in PDP-11 assembly language--it sported a swath of features now considered essential to roff systems: definition of macros (.de), diversion of text thence (.di), and removal thereof (.rm); trap planting (.wh; "when") and relocation (.ch; "change"); conditional processing (.if); and environments (.ev). Incremental improvements included assignment of the next page number (.pn); no-space mode (.ns) and restoration of vertical spacing (.rs); the saving (.sv) and output (.os) of vertical space; specification of replacement characters for tabs (.tc) and leaders (.lc); configuration of the no-break control character (.c2); shorthand to disable automatic hyphenation (.nh); a condensation of what were formerly six different requests for configuration of page "titles" (headers and footers) into one (.tl) with a length controlled separately from the line length (.lt); automatic line numbering (.nm); interactive input (.rd), which necessitated buffer-flushing (.fl), and was made convenient with early program cessation (.ex); source file inclusion in its modern form (.so; though RUNOFF had an ".append" control word for a similar purpose) and early advance to the next file argument (.nx); ignorable content (.ig); and programmable abort (.ab). Third Edition Unix also brought the pipe(2) system call, the explosive growth of a componentized system based around it, and a "filter model" that remains perceptible today. Equally importantly, the Bell Labs site in Murray Hill acquired a Graphic Systems C/A/T phototypesetter, and with it came the necessity of expanding the capabilities of a roff system to cope with proportionally-spaced type, multiple type sizes, and a variety of fonts. Ossanna wrote a parallel implementation of nroff for the C/A/T, dubbing it troff (for "typesetter roff"). Unfortunately, surviving documentation does not illustrate what requests were implemented at this time for C/A/T support; the troff(1) man page in Fourth Edition Unix (November 1973) does not feature a request list, unlike nroff(1). Apart from typesetter-driven features, Unix Version 4 roffs added string definitions (.ds); made the escape character configurable (.ec); and enabled the user to write diagnostics to the standard error stream (.tm). Around 1974, empowered with multiple type sizes, italics, and a symbol font specially commissioned by Bell Labs from Graphic Systems, Brian Kernighan and Lorinda Cherry implemented eqn for typesetting mathematics. In the same year, for Fifth Edition Unix, Ossanna combined and reimplemented the two roffs in C, using preprocessor conditions of that language to generate both from a single source tree. Ossanna documented the syntax of the input language to the nroff and troff programs in the "Troff User's Manual", first published in 1976, with further revisions as late as 1992 by Kernighan. (The original version was entitled "Nroff/Troff User's Manual", which may partially explain why roff practitioners have tended to refer to it by its AT&T document identifier, "CSTR #54".) Its final revision serves as the de facto specification of AT&T troff, and all subsequent implementors of roff systems have done so in its shadow. A small and simple set of roff macros was first used for the manual pages of Unix Version 4 and persisted for two further releases, but the first macro package to be formally described and installed was ms by Lesk in Version 6. He also wrote a manual, "Typing Documents on the Unix System", describing ms and basic nroff/troff usage, updating it as the package accrued features. Sixth Edition additionally saw the debut of the tbl preprocessor for formatting tables, also by Lesk. For Unix Version 7 (January 1979), McIlroy designed, implemented, and documented the man macro package, introducing most of the macros described in groff_man(7) today, and edited volume 1 of the Version 7 manual using it. Documents composed using ms featured in volume 2, edited by Kernighan. Ossanna had passed away unexpectedly in 1977, and after the release of Version 7, with the C/A/T typesetter becoming supplanted by alternative devices such as the Mergenthaler Linotron 202, Kernighan undertook a revision and rewrite of troff to generalize its design. To implement this revised architecture, he developed the font and device description file formats and the device-independent output format that remain in use today. He described these novelties in the article "A Typesetter-independent TROFF", last revised in 1982, and like the troff manual itself, it is widely known by a shorthand, "CSTR #97". Kernighan's innovations prepared troff well for the introduction of the Adobe PostScript language in 1982 and a vibrant market in laser printers with built-in interpreters for it. An output driver for PostScript, dpost, was swiftly developed. However, due to AT&T software licensing practices, Ossanna's troff, with its tight coupling to the capabilities of the C/A/T, remained in parallel distribution with device-independent troff throughout the 1980s, leading some developers to contrive translators for C/A/T-formatted documents to other devices. An example was vtroff for Versatec and Benson-Varian plotters. Today, however, all actively maintained troffs follow Kernighan's device- independent design. Regards, Branden [1] "The Evolution of the Unix Time-Sharing System", Ritchie, 1984 [2] Formatted with: groff -man -P-c -Tascii -rLL=72n -rHY=0 -dAD=l build/man/roff.7 (The `AD` string is new to groff 1.23 man(7).)

The earliest known text-formatting software, TJ-2, was created by MIT-trained computer scientist Peter Samson in 1963.

Beyond base duplication, numerous companies published parts of them and in particular parts if not all of the roff manual. For instance, a firm in Seattle called CSSC published a number of reference guides and use guides based on them

On Wed, Jan 12, 2022 at 01:48:58AM -0700, arnold(a)skeeve.com wrote: Only in some very minor ways, the author and I chatted and I cleared up some of his thinking. With all due respect to him, I wasn't impressed with the source base, it was C++ (I think) and slow (I know).

On Jan 10, 2022, at 7:13 PM, Lyndon Nerenberg (VE7TFX/VE6BBM) &lt;lyndon(a)orthanc.ca&gt; wrote: Greg 'groggy' Lehey writes: Well there is mandoc(1). But as time goes by they just seem to be re-implementing nroff. Of course that *must* be easier than just learning n/troff in the first place :-P

On Sat, Jan 01, 2022 at 09:07:49AM +1000, George Michaelson wrote: I was program committee chair for Linux Expo in 1999 (all that means is I formatted the proceedings into a book). I let people use LaTex but encouraged troff. A few people tried out troff and their reaction was "Wow, that was so easy and groff is really fast!" The only negative reaction was table of contents complaints, LaTex is 2 pass so it can do them, roff is one pass so you have to fiddle with things. A lot. I've used *roff for almost 40 years and I've never had the urge to use something else. I wrote a paper a while back where they insisted on LaTex and it just made me like *roff more. It's Betamax and VHS all over again, the crappy answer won.

My big complaint with stuff like Rust, or even Go (sorry Rob), is that they picked a different syntax. Why not just use C syntax and extend it to do what you want? Why must every project redo everything.

On Sat, Jan 01, 2022 at 08:04:58PM -0500, John Cowan wrote: I'm almost speechless. My progression was Basic, Pascal, C (and later Fortran, Lisp, no Cobol, I did an Ada Compiler so Ada I guess). Then on to awk, perl, tcl, I tried to like C++ but couldn't, tried to like Rust, Go, D, and couldn't.

If you think any of those other languages remotely approach the elegance of C, I just don't know what to say.

I'm almost speechless. My progression was Basic, Pascal, C (and later Fortran, Lisp, no Cobol, I did an Ada Compiler so Ada I guess). Then on to awk, perl, tcl, I tried to like C++ but couldn't, tried to like Rust, Go, D, and couldn't. If you think any of those other languages remotely approach the elegance of C, I just don't know what to say.

will be doing but it isn't assembler.

In 79-82 Runoff got me my undergraduate texts formatted on a dec10. Moving to work post degree on Unix and vms systems (my memory is that for some reason VMS didn't have runoff) I had the Normalised "oh this must be the same" hitting roff/nroff and got really confused by having both ms and me macros.

I actually strongly prefer TeX/LaTeX to *roff. But LaTeX does have its Knuthian and Stanfordish peculiarities. It helps if you read The TeXbook first and understand Tex's macro weirdness and \catcodes. Both systems have their blind spots. Ditroff fixes most of the big ones in nroff/troff, of course... Chris