PSChess – A chess engine in PostScript | Hacker News Reader

PSChess – A chess engine in PostScript

seriot.ch

203 pointsbeefburger23 comments

Open articleView on HN

For folks who want to learn more, the "Green Book" _PostScript Language Program Design_ is a classic:

https://www.goodreads.com/book/show/3883749-postscript-langu...

and _Thinking in PostScript_ was made available from the author's site and is widely available as a PDF:

https://w3-o.cs.hm.edu/users/ruckert/public_html/compiler/Th...

For a more typical usage see:

https://personal.math.ubc.ca/~cass/graphics/manual/

(I used to do PostScript programming on my NeXT Cube for custom fills and strokes in Altsys Virtuoso)

Oh, NeXT Cube and custom fills? That's pretty hardcore. Did you find programming in PostScript more intuitive compared to other languages, especially for graphical stuff?

The Cube was a gift, and the PS work didn't go that far.

I found PS pretty inscrutable, esp. the function-filled variant used in Virtuoso, but did manage to get dimension lines coded up (which promptly ran into precision problems which I eventually gave up on).

OpenSCAD is a lot more approachable, and METAPOST was easy to pick up and make use of:

http://ftp.tug.org/TUGboat/tb40-2/tb125adams-3d.pdf

Still working through this at:

https://willadams.gitbook.io/design-into-3d/3d-project

and mostly using visual tools (which arguably is limiting me) https://www.blockscad3d.com/editor/ and https://github.com/derkork/openscad-graph-editor and of course, had to throw: http://pythonscad.org/ into the mix. Still a bit miffed that Nodebox and Processing or maker.js weren't a good fit.

Even the official reference book ("red book" or PLRM, https://www.adobe.com/jp/print/postscript/pdfs/PLRM.pdf) is readable and very well done.

Nice work! Interesting convention on naming procedures. I'm not sure I could deal with the verbosity, but it is probably a good idea for bigger programs.

I've written neural network (ConvNet) in PostScript and this post has inspired me to finish it up and publish a blog post this week.

ZMachine in PS:

      gs -dNOSAFER zmachine.ps -- game.z3

 http://zzo38computer.org/zmachine/interp/zmachine.ps

PostScript is deep magic that I admire from a distance.

This is some mad scientist stuff. Great work.

I've done a bit of PostScript programming in the dim and distant past - the most ambitious of which was a "pretty-printer" for the YAM email client on Amiga, which otherwise just printed emails as plain ASCII.

I found PostScript to be one of those things where something "clicks" after a while, and I really started to appreciate the elegance and simplicity. The hardest part is the mental gymnastics required to track what's on the stack and in what order!

OP here. Indeed, hardest part is the initial mental gymnastics. This can be overcome by devising and enforcing some conventions that I wrote about in a separate article https://seriot.ch/projects/programming_in_postscript.html

If you want an accessible introduction to postscript that does a bunch of very pretty pictures you can't go wrong with: https://personal.math.ubc.ca/~cass/graphics/text/www/

I particularly like chapter 14 where you implement 3d shader in postscript.

> PostScript is deep magic

Why do you say that? It's a very simple and tiny language that you can learn in an afternoon. Far from the utter complexity of modern things. It's barely more complicated than a programmable calculator. Certainly simpler, cleaner, and arguably more powerful than svg graphics.

You don't even need to read any manual to guess what this example program does:

   100 100 moveto 
   200 300 lineto
   stroke

I have absolutely no idea what that program is intending to do, such that I can’t tell if you’re joking.

It draws a straight line.

x coord, y coord, command that consumes the arguments from what we can infer is pushed onto a stack beforehand

Your guess is as good as mine, but I assume it draws a line from coordinates (100, 100) to (200, 300)

The drawing part is pretty straightforward. It’s the stack-based approach and reverse Polish notation thing that trips me off.

Very cool stuff, but not what I do day to day, so it’s a bit intimidating at first.

I’d most certainly need to read a manual to know what this does.

Is there an implicit bounding box? How large is it? Does x or y go first in the parameters?

> Certainly simpler, cleaner, and arguably more powerful than svg graphics.

Much more powerful, I agree. Some might even say a bit too powerful for a graphics description language, halting problem and all.

> Far from the utter complexity of modern things.

Although it would, at times, go wrong there are very few things to this day that do impress me more than typing this (admire my "useless use of cat" btw):

    ... $   cat tiger.ps | netcat 192.168.0.78 9100

And see my HP LaserJet 4M+ (speaking PostScript natively) start printing.

Yeah, yeah, yeah, I do have a SOHO and a modern printer/scanner at home and it can do more stuff.

But the elegance of netcat'ing a PostScript file to a printer and seeing it print without needing any driver nor any configuration whatsoever [1] was quite something.

It was simpler indeed and it was elegant and it did feel like magic.

Now it wasn't fun if you printed many pages and suddenly it started printing garbage but still...

[1] you had to configure the printer itself to get an IP, but that was done on the printer itself

It is truly awesome. I never get tired of this trick.

PostScript's magic is subtle. I once tried writing a PostScript interpreter in ADA. Got far enough to display the turkey example and realized that PostScript code can modify itself and decided I didn't want to go there.

It's not a terrible language; it just requires a little different thinking. In 1988/89, I learned to write a postscript generator with no dev environment, just reams of paper. Debugging was hard since you had to add debugging print statements in the same document you were printing, which was hard if no printing occurred! I read Adobe Illustrator files, which were the precursor to PDF, so at least I had something to look at.

xxkndfvdjwxxxxxxxxxxxxxxxxxxxxxxxxypppppppxxxxoxoxxoxoxoxoxoxooxoxxooxoxxoxoxoxoxo

A nice showcase of Postscript's abilities, which I first became aware of around 1990, when I sent a tiny program to a Postscript printer to generate a 1024x1024 maze, taking half a day to finish. The graphics are simple but good looking. The engine is weak as expected for a tiny engine. The game I played with my first 4 moves of e2e4, d2d4, e4e5, and d4d5 resulted in checkmate on move 18. I wasn't sure if it would accept en-passant capture but it did. Other tiny engines like Micro-Max [1] and nanochess [2] are much stronger. An interesting long running (2009-2021) discussion between their authors may be found on the chess programming forum [3].

[1] https://home.hccnet.nl/h.g.muller/max-src2.html

[2] https://nanochess.org/chess3.html

[3] http://talkchess.com/forum3/viewtopic.php?f=7&t=26622

Reply on news.ycombinator.com