
English: 
Back in the early 1980s John Warnock, 
the founder of Adobe, had invented
PostScript. He'd pioneered all their work
of getting a PostScript interpreter 
embedded into laser printers. He persuaded
Steve Jobs, at the time, to say: "When your
new Macintosh comes out we want it to be
almost a dual announcement - at the same
time". But they didn't quite make it. The
Macintosh did come out, first of all
- the little 9-inch [screen] one, that we've 
done videos on but alongside it, fairly shortly
afterwards was the Apple laser printer. John 
had got the "killer app.", he thought, to
show off the skills and wonder of his
laser printer driving, with PostScript,
the output. And that killer example was
a United States Income Tax form for
Supplementary Income. So he programmed
this up in his PostScript language. You

Thai: 
ย้อนกลับไปในช่วงต้นทศวรรษ 1980 จอห์น วอร์น็อค, 
ผู้ก่อตั้งของ Adobe ที่ได้คิดค้น
PostScript เขาเป็นผู้บุกเบิกในงาน
ตัวแปลภาษาใน PostScript ทั้งหมด
ที่ฝังติดตั้งในเครื่องพิมพ์เลเซอร์ เขาชักชวน
สตีฟ จ็อบส์ ตอนนั้น พูดว่า:
"เมื่อ Macintosh คุณออกมาใหม่ เราอยากให้มัน
เกือบจะเป็นการประกาศสองสิ่ง - ในเวลาเดียวกันนั้นเลย "
แต่พวกเขาก็ทำไม่ได้  ตอน
แมคอินทอชออกมา
อย่างแรกเลย - ตอนขนาด 9 นิ้ว [หน้าจอ] หนึ่งล่ะ
 ที่เราได้ทำคลิปไป
หลังจากนั้น เป็นเครื่องพิมพ์เลเซอร์ของแอปเปิ้ล 
จอห์นได้ "นักฆ่า แอป(เปิ้ล)." เขาคิด
ที่จะโชว์ออฟ และสงสัยในผลลัพธ์ที่
เครื่องพิมพ์เลเซอร์ของเขาที่มีไดรฟ์เวอร์  PostScript
และตัวอย่างที่เป็นนักฆ่า คือ 
แบบฟอร์มภาษีเงินได้รายสำหรับได้เสริมของสหรัฐอเมริกา
ดังนั้นเขาจึงทำโปรแกรมนี้
ขึ้นในภาษา PostScript ของเขา

Thai: 
คุณส่งมันไปที่ LaserWriter ของแอปเปิ้ล ซึ่ง
มันรวดเร็ว จนคุณจะไม่อยากจะเชื่อเลย !
แต่มันต้องใช้เวลานาทีกว่าได้ภาพ
ออกมา และนั่นละ
สตีฟ จ๊อบ ว่า "จอห์น ฉันรู้วิธีที่จะนำเสนอ แต่
ฉันรั้งพวกเขา [ผู้ชม] เป็นเวลาหนึ่งนาที
กับอีกหนึ่งในสี่ของนาทีไม่ได้ ในขณะที่เรากดปุ่ม
และเรารอคอยภาพออกมา และไฟที่
ด้านหน้า [ของ LaserWriter] มันกระพริบๆๆ"
ดังนั้น จอห์นเป็นนักวิทยาศาสตร์คอมพิวเตอร์ที่ดีมาก
และรู้ทุกอย่างเกี่ยวกับภาษา PostScript 
ของเขาเอง กล่าวว่า "ใช่
สิ่งที่ต้องทำ สตีฟ คือ ลบขั้นตอนทั้งหมด
เพียงแค่ทำให้มัน ลบออกอัตโนมัติ
และคลายลูป และทำให้
ให้แน่ใจว่า ทุก คำสั่ง 'if'
ที่เรารู้ว่า ข้อมูล จะเข้าสู่ 'if' นั่น
ดังนั้นทำให้เรารู้วิธีที่มันเข้าไป
จะไปผ่านเส้นทางไหนในโปรแกรม ดังนั้นเราจะ
ให้โปรแกรมเรียบง่ายลงไปอีกได้ - ซึ่ง บางครั้งเรียกว่า
เรากำลังจะไป linearize มัน (ทำให้เป็นเส้นตรง) 
เรากำลังจะไปผูกกับข้อมูลและพูดว่า: "เราต้องการเส้นทางที่เร็วที่สุด
เพื่อผลภาพสุดท้าย ". ดังนั้น นั่นคือ
สิ่งที่เขาทำและรุ่นคลี่ลูป

English: 
sent it down to the Apple Laserwriter which 
was so fast you couldn't believe it (!)
But it took a minute and a quarter to
image it. And the wondrous Jobs, of
course, said: "John I know how to present but
I cannot hold them [the audience] for one minute
and a quarter while we press the button
and we wait for it to come out. And the light
at the front [of the Laserwriter] is going blink, 
blink, blink"!  So John, being a very good computer
scientist and knowing all about his own
language, PostScript, said: "Yeah, what we've
got to do, Steve, is remove all the
procedures, just get them automatically
removed and unroll the loops and make
sure that every 'if' statement that we
know what data goes into that 'if'
statement so we know which way it's
going to go through the program. So we're going
to flatten the program - as it's sometimes called.
We're going to linearize it; we're going to bind 
in the data and say: "We want the fastest route
to the final visual effect". So that's
what he did and the unrolled version

Thai: 
ให้ภาพใน 20 วินาที - ไม่ได้เป็นนาทีกว่า
ดังนั้นจึงทำงานได้จริงๆ
เราสอนนักเรียนของเราอย่างระมัดระวัง
หลักการเขียนโปรแกรมที่ดี เราสอน
พวกเขาใช้ บล็อก (block) ลูป  'for' สเตทเมนท์ 'if' 
ในการเขียนโปรแกรมเชิงโครงสร้าง
Oh! และเหนือสิ่งอื่นใด คือไม่ดีกว่าหรือ
ที่จะเอาทั้งยวงหนึ่งออกไปตั้งเป็น procedures หรือ
ซับรูทีน(subroutine) - อะไรที่คุณเรียกมัน
และจะเรียกพวกมันมาใช้เมื่อมีอาร์กิวเมนต์(argument) ที่เหมาะสม
มันดูสะอาดตา และ ดี และมีโครงสร้าง และ
ทำให้คุณได้รับเกรดที่ดีมากในการเรียนของคุณ
ภายใต้การทำสิ่งเหล่านี้ คุณมักจะต้อง
จำไว้ว่ามันมีค่าปรับนิดหน่อย
ประสิทธิภาพการทำงานที่ชาญฉลาดที่จะต้องจ่าย
สำหรับทำทั้งหมดนี้ หากคุณเพียงแค่พิจารณา
ลูป  'for' เช่น ทุกครั้งที่คุณไป
ในวงรอบลูปนั่น คอมไพเลอร์สร้าง
กลไกในการตรวจสอบที่ด้านบน 
พูดว่า "คุณบอกว่าเริ่มต้นที่ 1 และเพิ่ม
ทีละ 1 ไปจนกว่าคุณจะถึง 6 และ
ทำมันเป็นรอบ ๆ เช่นนั้น และ

English: 
imaged in 20 seconds - not a minute and a
quarter. So it really did work.
We teach our students very carefully
good programming principles. We teach
them to use 'if' statements 'for' loops
blocks,  structured programming.
Oh! and above all else isn't it nice to
hive stuff off into procedures or
subroutines - whatever you want to call them.
And to call them up with suitable arguments.
It's clean and nice and structured and
gets you very good grades in your coursework.
Under the hood you always have to
remember that there is a bit of a
penalty, performance-wise, to be paid for
doing all this. If you just consider the
humble 'for' loop, for example. Every time
you go round that loop the compiler is
building in a checking mechanism, at the
top, saying: "You said start at one and in
steps of 1 go on until you get to 6. And
do it around the loop like that. And

English: 
every time we go in that loop it has to
say 'What's my loop counter at the moment
Oh! I'm on three. Now, let me take a look
at how far I'm supposed to  -- oh! 6. 
Is three less than six. Yes it is!
Oh! I think we'd better go round again".
I exaggerate -  but you know what i'm
getting at. Equally if you dive into a
procedure and you call it up with arguments
do remember - from what we've done already - 
that that causes stack frames to be set up to
propel your arguments to that function
and to post them into the function and
then when the function has finished doing 
its job 
it has to clear down that stack frame.
And if the function is recursive there
might be the zillions of stack frames to be
cleared down.
It's all overhead, but it's overhead
that you're probably prepared to pay
because it helps you think about the
problem and do it neatly and elegantly.
But, if you're concerned with performance
of your program to the nth degree,

Thai: 
ทุกครั้งที่เราจะไปในวงลูป มันต้องบอกว่า
'ในขณะนี้ ตัวนับของฉันคืออะไรนะ
Oh! 3 ตอนนี้ให้ฉันจะดู
ที่ไกลแค่ไหนที่ฉันควรจะไปได้ - Oh! 6
สามน้อยกว่าหกใช่มั้ยนะ? ใช่แล้ว!
Oh! ผมคิดว่าเราควรที่จะไปวนรอบอีกครั้ง '
ผมพูดโอเวอร์แอ๊คติ้ง - แต่คุณรู้ว่ามันคือสิ่งที่ผม
จะอธิบาย เหมือนกัน ถ้าคุณดำลงไปใน procedure และ คุณ
เรียกมันขึ้น ด้วย argument (ค่าที่ส่งผ่านไปให้จากโปรแกรมหลัก)
จำได้มั้ย - จากสิ่งที่เราได้ทำมาแล้ว - 
ทำให้เกิด กรอบ stack จัดตั้งขึ้น เพื่อ
ขับเคลื่อน argument ของคุณ สู่ฟังก์ชั่นนั่น
และเพื่อที่จะประกาศมันไว้ในฟังก์ชั่น
แล้วเมื่อฟังก์ชั่นได้เสร็จสิ้น
การทำงานของมัน
จะมีการล้าง กรอบ stack ออก
และถ้าฟังก์ชันนี้จะมีการเรียกซ้ำ(recursive)
อาจจะมีเฟรมสแต็คนับล้านๆ 
ที่ต้องล้างออก
มันเป็นค่าใช้จ่ายส่วนเกิน แต่ก็เป็นค่าใช้จ่าย
ที่คุณอาจจะเตรียมที่จะจ่าย
เพราะมันจะช่วยให้คุณคิดจัดการเกี่ยวกับปัญหา
และทำมันได้อย่างเรียบร้อยและสวยงาม
แต่ถ้าคุณกังวลเกี่ยวกับประสิทธิภาพของโปรแกรม
ของคุณจะไปถึงดีกรีที่ n (ประสิทธิภาพไม่ดี)

English: 
these overheads can begin to tell and
sometimes to get the optimum/maximum
performance, under specialist conditions,
you might want to say: "Rather than going
around this 'for' loop six times and doing
pretty well exactly the same
thing, I will write it out, by hand, six
times and forget the 'for' loop". Would that
be quicker? The answer is, very often, "Yes".
What I thought I'd do, in the true
spirit of Computerphile - this little
example that we'll do now - we want to
print out six Computerphile banners. Look
at that! Correct fonts and everything! As
you all know it's called OCR-A. I'm afraid
that my printer is a bit deficient. It's
knocked off the corner of the pointy bracket
- but please forgive.
OK - so how do we do it just using a 
PostScript 'for' loop?
Well, very briefly, I'll go through this
with you. More details available on the
specialist PostScript video if you need
it. Every PostScript program has to start
with %!   This says I am PostScript from now on

Thai: 
ค่าใช้จ่ายเหล่านี้ สามารถเอามาคำนึงถึงได้และ
บางครั้ง เพื่อที่จะได้มีประสิทธิภาพที่ดีที่สุด / สูงสุด
ภายใต้เงื่อนไขพิเศษ
คุณอาจจะพูดว่า: "แทนที่จะไป
วนในรอบ 'for' นี้ 6 ครั้ง
และสิ่งที่ได้ออกมาเหมือนกัน
ผมจะเขียนมันออกมา ด้วยมือ 6 ครั้ง
และลืม 'for' ลูป นี้ซะ ".
จะเร็วกว่ามั้ย? คำตอบคือ โดยมากมัก จะ "ใช่"
สิ่งที่ผมคิดว่า ผมจะทำ ในจิตวิญญาณที่แท้
ของ Computerphile - ตัวอย่างเล็ก ๆ น้อย ๆ นี้
ที่เราจะทำตอนนี้ - เราต้องการที่จะ
พิมพ์ Computerphile ออกมา 6 ป้าย
ดูนั่น! แบบอักษรที่ถูกต้องและทุกอย่าง! 
เช่นที่ทุกคนรู้ว่า มันเรียกว่า OCR-A
ฉันกลัวว่าที่เครื่องพิมพ์ของฉันไม่ค่อยดี
มันทำมุมของวงเล็บแหลมหล่น
- แต่โปรดยกโทษให้
OK - ดังนั้นวิธีการที่เราจะทำก็แค่ใช้ 
ลูป  'for' PostScript?
อืม อย่างสั้น ๆ เลย 
ผมจะลงลึกในรายละเอียดเพิ่มเติม
ที่ในวิดีโอ ผู้เชี่ยวชาญ PostScript ถ้าคุณต้องการมัน
ทุกโปรแกรม PostScript เริ่ม ด้วย %!
นี่มันบอกว่า ฉันเป็น PostScript นะ ต่อจากนี้ไป

Thai: 
ความคิดเห็น (Comment) ในโปรแกรม PostScript เริ่มต้นด้วย
% ในคอลัมน์ 1 ดังนั้น [นี่คือ] โปรแกรมสำหรับ
Computerphile 6 ป้าย กำหนด(def) ตัวแปร 'n' 
เป็น 6. นี่คือคำสั่ง PostScript
เรียก 'selectfont' ซึ่งบอกว่าคุณต้องการตัวอักษร
แบบไหน
และขนาดที่คุณต้องการจะทำ
เรากำลังพูดว่า: "ค้นหาตัวอักษรที่เรียกว่า OCR-A
และในขนาด 30 จุด (point) ทำสำเนาให้ฉัน
ของสิ่งนี้ที่พร้อมสำหรับการใช้งานใน PostScript
ที่นี่ PostScript ทำทุกอย่างย้อนกลับหลัง
แต่ได้อย่างมีประสิทธิภาพ
มันเรียบง่ายมาก
มันเป็นลูป  'for' คือ มันบอกว่า สำหรับ -
เริ่มต้นที่ 1 และนับไปทีละ 1 ถึง 'n'
( แต่เรารู้ว่า 'n' คือ 6) ดำเนินการต่อไปนี้
รหัสภายในวงเล็บปีกกาเหล่านี้
ตอนนี้บรรทัดต่อไปคือการบอกว่าเราต้องการ "Computerphiles"  6 อัน
และพวกมันทั้งหมดควรจะอยู่ที่ 10 จุด (point)
จากขอบและพวกมันควรจะเป็น
100 จุด (point) ห่างจากกัน

English: 
Comments in PostScript programs begin with
% in column 1. So [here is]  a program for six
Computerphile banners. Define the variable 'n' 
to be 6. Here is the PostScript command
called 'selectfont' which says what font
you want and what point size do you want
to do it at.
We're saying: "Find the font called OCR-A
and, at point size 30, make me a copy of
that ready for use in PostScript. Here
PostScript does everything backwards in
Reverse Polish notation, but effectively
it is very simple.
It's a 'for' loop so it's basically saying: for -
starting at one and in steps of one up to 'n'
(but we know 'n' is 6) do the following
code inside these curly braces. Now the
next line is saying we want six "Computerphiles" 
and they should all be at 10 points
in from the margin and they should be a
100 points apart.  When you look at

Thai: 
เมื่อคุณดูที่นี่อย่างละเอียดที่ฉันทำพวกมันขึ้นบน
ไม่ลงล่าง ตอนนี้คุณสามารถเห็นสิ่งที่เกิดขึ้น
เมื่อคุณเริ่มพิมพ์งานออกมา อาจจะออกแบบสำหรับ
US Letter บนกระดาษขนาด A4
10 จุดของคุณ - มันคืออะไร 72 จุด ต่อนิ้ว ?
ผมพยายามที่จะทำเยื้องมา
หนึ่งในเจ็ดของนิ้วและมันทำไม่ได้!
จะต้องไปจัดการกับขนาดกระดาษ
แต่ยังไงก็ตาม ขึ้นหน้าแล้ว มันเป็น
การเพิ่มขึ้น 100 จุด ซึ่งมากกว่า
หนึ่งนิ้วแค่นิดหนึ่ง
หก  "Computerphile" อัน ทั้งหมด
พิมพ์ออกมาอย่างสวยงาม และนั่นคือ
ในตอนท้าย ลูป  'for' ของคุณ และในที่สุด
- มันได้ทำ - ภาพนี้ให้คุณ
ภายในหน่วยความจำกราฟิกของตัวเอง แต่ถ้าคุณ
อยากให้มันปรากฏขึ้นบนหน้าจอของคุณหรือ
ในท้ายที่สุดบนกระดาษสักชิ้น คุณบอก 'showpage' 
ขณะนี้บางตัวแปลภาษา PostScript,
หากมันมาถึงสิ้นสุดไฟล์ และคุณไม่ได้ 
บอกว่า 'showpage' มันจะใส่ 'showpage'
ให้คุณ.  นั่นไง 'showpage'
นี่คือสิ่งที่มันทำ

English: 
this carefully I'm doing them upwards, not
downwards. Now you can see what happens
when you start printing out stuff,
probably designed for US Letter, on to A4
paper.  Your 10 point. - what is it, 72 points 
an inch?  I tried to do a
one-seventh of an inch indent and it didn't work!
It's all to do with paper sizes but
anyway, going up the page, it's a
100-point increments which is just a bit
more than an inch. Six
instances of "Computerphile" all
beautifully printed out. And there's the
end of your 'for' loop. And finally it has
- as it were - virtually imaged this for
you inside its own graphic memory. But if you
wanted it to show up on your screen, or
ultimately an your piece of paper, you say
'showpage'. Now some PostScript interpreters,
if it gets to end of file and you haven't 
said 'showpage' will put a 'showpage' in 
for you. There's the 'showpage'.
Here's the thing done,

Thai: 
ไม่ได้อยู่ใน  ลูป  'for' แต่เขียนออกมา คำสั่ง 6
การเรียกใช้ แยกจากกัน เพื่อที่จะ
พิมพ์ "Computerphile" ออก ที่ 30 จุด คุณอาจ 
พูดว่า: อืมม คุณใช้สิ่งเหล่านี้อย่าง 'show'
และ 'moveTo' และ 'showpage' และนี่
บนสำเนานี้  ไม่เอาน่า! ไม่ ผมพยายามที่จะ
แสดงให้คุณเห็นบางสิ่งบางอย่าง ซึ่งจะมีประโยชน์
ให้เราในภายหลัง - ที่ PostScript ให้คุณ
กำหนดตัวดำเนินการ (operator) ใหม่ได้
และย่อชื่อของพวกมัน หากคุณต้องการ
ดังนั้น ที่ด้านบนนี่ ผมพูดว่า: "ดู
กำหนดเพียงแค่ตัวอักษร 's' จะเป็น
operator 'show' กำหนด 'm' จะเหมือนกับ
เป็น 'moveTo' ตอนนี้คำว่า 'bind' ก็หมายความว่า:
"จำได้ว่า ฉันเคยทำคำนิยามนี้และ
ไม่อนุญาตให้กำหนดคำนิยามนี้ใหม่อีก
ที่อาจจะทำสิ่งที่ยุ่งเหยิงได้ อย่าปล่อยให้
ใคร .... ข้างต้นทั้งหมดไม่ให้แม้แต่ตัวคุณเอง 
- ทำผิดพลาด - พยายามเปลี่ยนมันอีกครั้ง ".

English: 
not in a 'for' loop but writing out six
separate calls of the command to print
out "Computerphile" at 30 point. You might 
say: "Well you used things like 'show'
and 'moveto' and 'showpage' and here, on
this copy, you're not! No, I'm trying to
show you something which will be of use
to us later on -- that PostScript enables
you to redefine operators and to
abbreviate their names if you want to.
So, up at the top here I say: "Look
define, just the letter 's', to be the
operator 'show'. Define 'm' to be the same
as 'moveto'. Now the word 'bind' just means:
"Remember I've done this definition and
don't permit any other redefinitions
that might mess things up. Don't let
anybody .... above all don't let even yourself 
- making mistakes - try and change it again."

Thai: 
นั่นคือ 'm' ผูกไว้แน่นหนา  ที่จะเป็น 'moveTo'
 ผมเคยเรียก 'selectfont' โดยย่อว่า 'sf';
'showpage' เป็น 'sp' และดูสิ อันแรก
ว่า "10 200 m" และ
นั่น แล้วอีก แล้วอีก และ
ในที่สุด 'sp' ซึ่งเป็นคำย่อของ
'showpage' แต่ผมไม่ได้เขียนมันออกมาโดย
มือ - ผมทำโปรแกรม "เปลี่ยน" ที่จะทำมันออกมาให้
เพราะมัน โอเค ที่จะทำหกอันทั้งหมดนี้
โดยมีตัวย่อหวือหวานิดหน่อย
เป็นคำนิยามที่ด้านบน แต่ถ้ามันเป็น
10,000 รอบ ผมไม่ต้องการที่จะ
ทำซ้ำบางสิ่งบางอย่าง 10,000 รอบ ใน 
โปรแกรมแก้ไขสคริปต์ หรือ ด้วยมือ
นี่ก็เป็น สคริปต์ "เปลี่ยน" ซึ่งเราจะทิ้งไว้
ในหมายเหตุประกอบ ดังนั้นถ้าคุณ
ทำให้มันทำงานได้ เขียนหาเรา ใน comment จะได้มั้ย?
และกล่าวว่า "ใช่ ว้าว มันเวิร์ค!"
คุณควรสามารถที่เข้าใจว่าจะใช้งานมันยังไง
และผมควรพูดแบบนี้ นี่เป็นเวอร์ชั่นเรียบง่ายมากๆ
ของรุ่นของคลี่ลูป สคริปต์ "เปลี่ยน" 
ที่จอห์น วอร์น็อค ใช้
กลับไปในปี 1984 เพื่อให้ได้แบบฟอร์มภาษีรายได้ของเขา 
- ซึ่งก็ยังซับซ้อนกว่า

English: 
This is binding solidly 'm' to being
'moveto.  'selectfont' I've abbreviated as
'sf'; 'showpage' as 'sp'. And look the very first
one is there that's "10 200 moveto" and
there, and then another, then another and
finally 'sp' which is the abbreviation for
'showpage'. But I didn't write it out by
hand - I got a "transform" program to do
it for me. Because it's all right doing six
of these with a bit of fancy abbreviation
definitions at the top. But if it was
10,000 times round I don't want to
replicate something 10,000 [times] in an 
editor, or by hand.
Here's a "transform" script which we'll
leave there for in the notes. So  if you get
it working write us a comment will you?
And say: "Yeah! Wow! it worked for me".
You should be able to work out how to use it.
And i should say this is a much, much,
much simplified version of the unrolled
"transform" script that John Warnock used
back in 1984 to get his income tax form 
- which was far more

Thai: 
"Computerphiles" หก อันยิ่งนัก 
เพื่อให้พิมพ์ออกมาในเวลาที่เหมาะสม ไม่นานเกินไป
บน Apple LaserWriter เพียงหนึ่งข้อคิดเห็น
สุดท้าย สิ่งที่จอห์นได้ทำ และนี่คืออะไร
สะท้อนอยู่ใน คำย่อนี้ ที่นี่ ....
"ทำไมต้องวุ่นวายย่อ?"
คำตอบคือ: "เอาล่ะ  ถ้าคุณคลายลูปและ
ทำซ้ำสิ่งนี้ คุณกำลังทำไฟล์ใหญ่
มากขึ้นเรื่อยๆ". มีการพิมพ์อีกมากมาย
ไม่ได้มีอยู่ในไฟล์และ
นั่นไม่จำเป็นต้องเป็นสิ่งดี
เราสามารถลดไฟล์ขนาดลง? ใช่ ด้วยการทำ
ตัวย่อ และความเข้าใจนั้น ทำโดย
จอห์นในปี 1984 นั่นเป็นยุคเริ่มๆ ที่นานมาแล้ว
ของสิ่งที่เรารู้ว่าตอนนี้เป็นรูปแบบไฟล์ PDF
บรรยายไทยโดย  ytuaeb sciencemath

English: 
complicated than six "Computerphiles", to
print out in a reasonable amount of time
on the Apple Laserwriter. Just one final
comment. What John did and what this is
echoing here in this abbreviation  ....
"Why are you bothering to abbreviate?" The
answer is: "Well, if you unroll the loops and
replicate things, you're making files
bigger and bigger and bigger". Lots more
printing isn't there, in the file, and
that's not necessarily a good thing.
Can we keep file size down? Yes, by doing
abbreviations. And that realization, made
by John in 1984, was the very earliest
glimmerings of what we now know as PDF.
