On 03.11.24 22:02, the pterodactyl wrote:

> The only PostScript I've seen (destined for Apple LaserWriters) looks

> like it was written by a giant on a 8,192 column terminal and then loaded

> into Vim by a mere mortal.  I concur with the abuse, but have not

> discovered its beauty for myself.

After trying GIMP, and failing to find a way to draw a box, I gave up on

GUI drawing, and "drew" the eight sections, elevations, and plan views

for my owner-built off-grid retirement retreat - a 25m x 9.2m building

with internal masonry in the midst of timber framed walls - in

Postscript. It was easier.

With the help of a hierarchy of macros, beginning with "box", developing

to "window", "door", "wall", each taking size and orientation

parameters, the eight drawings took 896 lines of Postscript. OK, where a

25m run of wall included multiple windows and wall sections, I did put

several on a line, but kept that in check as comments were needed for

rapid location of the fiddly bits for a particular feature when editing.

Its power comes to the fore when features are repeated. Drawing 27 solar

panels in three rows on the roof, to dimension and precisely spaced, was

done with:

3 { 9 { 1728 292 box 50 0 rmoveto } repeat -16003 -400 rmoveto } repeat gstroke

< size >     <  >                  <         >

in mm     space                carriage return

(That did line up in Vim. Damn the ISP's GUI mail client.)

The only irritation is that Postscript debugging is exceedingly primitive. If a lot

has been added since the last successful output generation, then it can

be necessary to bisect the addition until the offending cause of the

crash is identified. I found that incremental editing, with frequent

output runs, was most productive. (Stack starvation, for example, can draw weird stuff.)

Incidentally, the drawings not only gained Planning Approval from local

council authorities, but also Building Approval from the licenced building

surveyor. I.e. they were good enough to build from. (OK, it was my

second owner-build, but I used an architectural draughtsman the first

time round, so this was a pleasing success.)

I did use Vim. Its folding feature presents the 896 lines of Postscript

source as an expandable TOC view:

------------------------------------------------------------------------

%!PS-Adobe-3.0

%%Creator: Erik Christiansen, using Vim, with folding. (Modelines at end)     %{{

%%BeginProlog  % In comments: % "S:" signifies stack contents, TOS to right.  %{{

%%EndProlog                                                                   %}}

<< /PageSize [842 1190] /Orientation 2 >> setpagedevice     % A3. This informs the printer.

%%BeginScript

%%Page: 1 4                                                                   %{{

% Accommodation Block:                                                        %{{

% Workshop Block:                                                             %{{

% Garage:                                                                     %{{

% Roof Outline:                                                               %{{

% Truss Placement:                                                            %{{

%%Page: 2 4                                                                   %{{

%Accommodation Block Section: AA                                              %{{

%Garage & Workshop Section:   BB                                              %{{

%East Elevation:                                                              %{{

%West Elevation:                                                              %{{

%%Page: 3 4                                                                   %{{

%North Elevation:                                                             %{{

%South Elevation:                                                             %{{

%%Page: 4 4                                                                   %{{

%Site Plan:                                                                   %{{

% vim: fdm=marker foldmarker=%{{,%}} foldlevel=0 commentstring=

%%EOF

------------------------------------------------------------------------

> As for assembler, one doesn't think like the computer--one *is* the

> computer, guts and glory.

I'm currently coding an off-grid power diverter, to use only excess

solar power for my HWS (USA: Boiler). When my 1/4 century old programmer

for the ATmega16 I've used here, convincingly played dead, I did a good

bit of code review while waiting for a replacement to arrive. With

assembler, that involves emulating each machine instruction mentally,

including any status register impact, when postponing a conditional

branch several instructions after the flag setting operation.

Fortunately, load and store operations have zero status impact, so a

variable save can be interposed between a subtraction (generating the

value to be saved) and a conditional branch to do stuff depending on the

result.

I've corrected over a dozen minute errors in nearly as many mental

emulations. Sharing data between an interrupt handler and the main loop requires mental alertness to what is "volatile", in C terms.

Assembler programming does offer amusements not otherwise easily

available. For example, the AVR core offers shifts and rotates through

the Carry bit, but no register-internal rotate. At 20 MIPS, it isn't

necessary to be maximally efficient, but that is the wont of an

assembler programmer, is it not?

We do have a couple of diverting threads at the moment. :-)