|
Warning: this is an htmlized version!
The original is here, and the conversion rules are here. |
;; (find-sh "cd ~/books/ && find * | sort")
;; (find-sh "cd ~/books/__comp/ && find * | sort")
;; «.abel» (to "abel")
;; «.abelson-sussman» (to "abelson-sussman")
;; «.aho» (to "aho")
;; «.allen» (to "allen")
;; «.augustsson» (to "augustsson")
;; «.baker» (to "baker")
;; «.barras» (to "barras")
;; «.barski» (to "barski")
;; «.bentley» (to "bentley")
;; «.bentley-pp» (to "bentley-pp")
;; «.bentley-morepp» (to "bentley-morepp")
;; «.bernardy-jansson-paterson» (to "bernardy-jansson-paterson")
;; «.bernardy-lasson» (to "bernardy-lasson")
;; «.blauth» (to "blauth")
;; «.bournez» (to "bournez")
;; «.brady» (to "brady")
;; «.buzzard-wp» (to "buzzard-wp")
;; «.chan-windmill» (to "chan-windmill")
;; «.chapman» (to "chapman")
;; «.chapman-systemF» (to "chapman-systemF")
;; «.chlipala» (to "chlipala")
;; «.choudhury-krishnaswami» (to "choudhury-krishnaswami")
;; «.colton» (to "colton")
;; «.coquand» (to "coquand")
;; «.crockford» (to "crockford")
;; «.dershowitz-gurevich» (to "dershowitz-gurevich")
;; «.dijkstra» (to "dijkstra")
;; «.dreyer» (to "dreyer")
;; «.dsls-of-math» (to "dsls-of-math")
;; «.dybjer» (to "dybjer")
;; «.dybjer-dtaw» (to "dybjer-dtaw")
;; «.dybjer-paulin» (to "dybjer-paulin")
;; «.eisenberg» (to "eisenberg")
;; «.ellis-ritchie» (to "ellis-ritchie")
;; «.escardo» (to "escardo")
;; «.fleuriot» (to "fleuriot")
;; «.gavranovic» (to "gavranovic")
;; «.gersting» (to "gersting")
;; «.graham» (to "graham")
;; «.graham-common-lisp» (to "graham-common-lisp")
;; «.graham-on-lisp» (to "graham-on-lisp")
;; «.graham-roots-of-lisp» (to "graham-roots-of-lisp")
;; «.harper» (to "harper")
;; «.hopcroft» (to "hopcroft")
;; «.icon-book» (to "icon-book")
;; «.ierusalimschy» (to "ierusalimschy")
;; «.impagliazzo» (to "impagliazzo")
;; «.kavvos» (to "kavvos")
;; «.kernighan-plauger» (to "kernighan-plauger")
;; «.kernighan-ritchie» (to "kernighan-ritchie")
;; «.knuth» (to "knuth")
;; «.kruskal-landwehr» (to "kruskal-landwehr")
;; «.kurt» (to "kurt")
;; «.levy» (to "levy")
;; «.levy-slides2018» (to "levy-slides2018")
;; «.levy-thpartsets» (to "levy-thpartsets")
;; «.levy-lambdanotes» (to "levy-lambdanotes")
;; «.libes» (to "libes")
;; «.loeliger» (to "loeliger")
;; «.marlow-peyton-jones» (to "marlow-peyton-jones")
;; «.martin» (to "martin")
;; «.massot-why» (to "massot-why")
;; «.mcbride» (to "mcbride")
;; «.mcbride-pivotal» (to "mcbride-pivotal")
;; «.mccarthy58» (to "mccarthy58")
;; «.meyer» (to "meyer")
;; «.milner» (to "milner")
;; «.monnier» (to "monnier")
;; «.monnier-typer» (to "monnier-typer")
;; «.monnier-cuc» (to "monnier-cuc")
;; «.monnier-smie» (to "monnier-smie")
;; «.monnier-evol» (to "monnier-evol")
;; «.nanevski» (to "nanevski")
;; «.norell» (to "norell")
;; «.norell-chapman» (to "norell-chapman")
;; «.norell-bo» (to "norell-bo")
;; «.orchard» (to "orchard")
;; «.orchard-codo» (to "orchard-codo")
;; «.orchard-rice» (to "orchard-rice")
;; «.ousterhout» (to "ousterhout")
;; «.o_keefe» (to "o_keefe")
;; «.oliveira» (to "oliveira")
;; «.paulson» (to "paulson")
;; «.perrone» (to "perrone")
;; «.peyton-jones» (to "peyton-jones")
;; «.pierce» (to "pierce")
;; «.pierce-atitapl» (to "pierce-atitapl")
;; «.plotkin» (to "plotkin")
;; «.plotkin-partdiff» (to "plotkin-partdiff")
;; «.raymond» (to "raymond")
;; «.reynolds» (to "reynolds")
;; «.rutten» (to "rutten")
;; «.queinnec» (to "queinnec")
;; «.salus» (to "salus")
;; «.scheinerman» (to "scheinerman")
;; «.sedgewick» (to "sedgewick")
;; «.seibel» (to "seibel")
;; «.steele-common-lisp» (to "steele-common-lisp")
;; «.steele-gabriel» (to "steele-gabriel")
;; «.stevenson» (to "stevenson")
;; «.stroustrup» (to "stroustrup")
;; «.sussman-wisdom» (to "sussman-wisdom")
;; «.thain» (to "thain")
;; «.wilkinson» (to "wilkinson")
;; «.yanofsky-mannucci» (to "yanofsky-mannucci")
;; «.zeilberger» (to "zeilberger")
;; «.free-as-in-freedom» (to "free-as-in-freedom")
;; «.levy-hackers» (to "levy-hackers")
;; «.stallman» (to "stallman")
;; «.kelty» (to "kelty")
;; «.agda» (to "agda")
;; «.agda-dtp» (to "agda-dtp")
;; «.agda-verified» (to "agda-verified")
;; «.awk» (to "awk")
;; «.bsd-toolbox» (to "bsd-toolbox")
;; «.clcrit» (to "clcrit")
;; «.cli-coreutils» (to "cli-coreutils")
;; «.clojure» (to "clojure")
;; «.coq» (to "coq")
;; «.csound» (to "csound")
;; «.css» (to "css")
;; «.epigram-ppdt» (to "epigram-ppdt")
;; «.git» (to "git")
;; «.git-internals» (to "git-internals")
;; «.git-progit» (to "git-progit")
;; «.git-progit2» (to "git-progit2")
;; «.git-fbu» (to "git-fbu")
;; «.haskell» (to "haskell")
;; «.haskell-hutton» (to "haskell-hutton")
;; «.haskell-hudak» (to "haskell-hudak")
;; «.haskell-rw» (to "haskell-rw")
;; «.haskell-2010» (to "haskell-2010")
;; «.html-1998» (to "html-1998")
;; «.javascript» (to "javascript")
;; «.latex» (to "latex")
;; «.lpeg-fromre» (to "lpeg-fromre")
;; «.lpeg-pmp» (to "lpeg-pmp")
;; «.lpeg-redz» (to "lpeg-redz")
;; «.lpeg-rel» (to "lpeg-rel")
;; «.lpeg-medeirosphd» (to "lpeg-medeirosphd")
;; «.lilypond» (to "lilypond")
;; «.lua-gems» (to "lua-gems")
;; «.make» (to "make")
;; «.maxima» (to "maxima")
;; «.maximabook» (to "maximabook")
;; «.maxima-chamberlin» (to "maxima-chamberlin")
;; «.maxima-urroz» (to "maxima-urroz")
;; «.maxima-fatemanphd» (to "maxima-fatemanphd")
;; «.maxima-fatemansimp» (to "maxima-fatemansimp")
;; «.maxima-minimal» (to "maxima-minimal")
;; «.maxima-workbook» (to "maxima-workbook")
;; «.maxima-advfree» (to "maxima-advfree")
;; «.maxima-diffeqs» (to "maxima-diffeqs")
;; «.maxima-vallejomor» (to "maxima-vallejomor")
;; «.maxima-by-example» (to "maxima-by-example")
;; «.prog-1» (to "prog-1")
;; «.ocaml» (to "ocaml")
;; «.penrose» (to "penrose")
;; «.python» (to "python")
;; «.python-downey» (to "python-downey")
;; «.R» (to "R")
;; «.ruby» (to "ruby")
;; «.rubyforrails» (to "rubyforrails")
;; «.rubynutshell» (to "rubynutshell")
;; «.pragmaticruby» (to "pragmaticruby")
;; «.scala» (to "scala")
;; «.scheme» (to "scheme")
;; «.little-schemer» (to "little-schemer")
;; «.shell» (to "shell")
;; «.smalltalk» (to "smalltalk")
;; «.squeak-by-example» (to "squeak-by-example")
;; «.squeak-robots» (to "squeak-robots")
;; «.pharo-by-example» (to "pharo-by-example")
;; «.ingalls-miranda» (to "ingalls-miranda")
;; «.st-by-ex» (to "st-by-ex")
;; «.byte-smalltalk» (to "byte-smalltalk")
;; «.ssh» (to "ssh")
;; «.unixtools» (to "unixtools")
;; «.unix-haters» (to "unix-haters")
;; «.unusual-effectiveness» (to "unusual-effectiveness")
;; «abel» (to ".abel")
;; (find-books "__comp/__comp.el" "abel")
;; http://www.cse.chalmers.se/~abela/
;; http://www.cse.chalmers.se/~abela/foetus/
(code-pdf-page "abelfoetus" "~/books/__comp/abel__foetus_termination_checker_for_simple_functional_programs.pdf")
(code-pdf-text "abelfoetus" "~/books/__comp/abel__foetus_termination_checker_for_simple_functional_programs.pdf" 1)
;; (find-abelfoetuspage)
;; (find-abelfoetuspage 1 "Contents")
;; (find-abelfoetuspage (+ 1 189) "Index")
;; (find-abelfoetustext "")
;; «abelson-sussman» (to ".abelson-sussman")
;; (find-books "__comp/__comp.el" "abelson-sussman")
;; (find-books "__comp/__comp.el" "sussman-wisdom")
;; (find-LATEXfile "catsem-slides.bib" "SICP")
;; (find-es "scheme" "sicp-pdf")
;; https://web.mit.edu/alexmv/6.037/
;; https://web.mit.edu/alexmv/6.037/sicp.pdf
;; https://github.com/sarabander/sicp-pdf
(code-pdf-page "sicp" "~/books/__comp/abelson_sussman__structure_and_interpretation_of_computer_programs.pdf")
(code-pdf-text "sicp" "~/books/__comp/abelson_sussman__structure_and_interpretation_of_computer_programs.pdf" 21)
;; (find-sicppage)
;; (find-sicptext "")
;; (find-sicppage 3 "Contents")
;; (find-sicptext 3 "Contents")
;; (find-sicppage 9 "Unofficial Texinfo Format")
;; (find-sicppage 12 "Dedication")
;; (find-sicppage 13 "Foreword")
;; (find-sicppage 19 "Preface to the Second Edition")
;; (find-sicppage 21 "Preface to the First Edition")
;; (find-sicppage 25 "Acknowledgments")
;; (find-sicppage (+ 28 1) "1 Building Abstractions with Procedures")
;; (find-sicppage (+ 28 6) "1.1 The Elements of Programming")
;; (find-sicppage (+ 28 7) "1.1.1 Expressions")
;; (find-sicppage (+ 28 10) "1.1.2 Naming and the Environment")
;; (find-sicppage (+ 28 12) "1.1.3 Evaluating Combinations")
;; (find-sicppage (+ 28 15) "1.1.4 Compound Procedures")
;; (find-sicppage (+ 28 18) "1.1.5 The Substitution Model for Procedure Application")
;; (find-sicppage (+ 28 22) "1.1.6 Conditional Expressions and Predicates")
;; (find-sicppage (+ 28 28) "1.1.7 Example: Square Roots by Newton's Method")
;; (find-sicppage (+ 28 33) "1.1.8 Procedures as Black-Box Abstractions")
;; (find-sicppage (+ 28 40) "1.2 Procedures and the Processes ey Generate")
;; (find-sicppage (+ 28 41) "1.2.1 Linear Recursion and Iteration")
;; (find-sicppage (+ 28 42) "Figure 1.3: A linear recursive process for computing 6!")
;; (find-sicptext (+ 28 42) "Figure 1.3: A linear recursive process for computing 6!")
;; (find-sicppage (+ 28 47) "1.2.2 Tree Recursion")
;; (find-sicppage (+ 28 54) "1.2.3 Orders of Growth")
;; (find-sicppage (+ 28 57) "1.2.4 Exponentiation")
;; (find-sicppage (+ 28 62) "1.2.5 Greatest Common Divisors")
;; (find-sicppage (+ 28 65) "1.2.6 Example: Testing for Primality")
;; (find-sicppage (+ 28 74) "1.3 Formulating Abstractions with Higher-Order Procedures")
;; (find-sicppage (+ 28 76) "1.3.1 Procedures as Arguments")
;; (find-sicppage (+ 28 83) "1.3.2 Constructing Procedures Using lambda")
;; (find-sicppage (+ 28 89) "1.3.3 Procedures as General Methods")
;; (find-sicppage (+ 28 97) "1.3.4 Procedures as Returned Values")
;; (find-sicppage (+ 28 107) "2 Building Abstractions with Data")
;; (find-sicppage (+ 28 112) "2.1 Introduction to Data Abstraction")
;; (find-sicppage (+ 28 113) "2.1.1 Example: Arithmetic Operations for Rational Numbers")
;; (find-sicppage (+ 28 118) "2.1.2 Abstraction Barriers")
;; (find-sicppage (+ 28 122) "2.1.3 What Is Meant by Data?")
;; (find-sicppage (+ 28 126) "2.1.4 Extended Exercise: Interval Arithmetic")
;; (find-sicppage (+ 28 132) "2.2 Hierarchical Data and the Closure Property")
;; (find-sicppage (+ 28 134) "2.2.1 Representing Sequences")
;; (find-sicppage (+ 28 147) "2.2.2 Hierarchical Structures")
;; (find-sicppage (+ 28 154) "2.2.3 Sequences as Conventional Interfaces")
;; (find-sicppage (+ 28 172) "2.2.4 Example: A Picture Language")
;; (find-sicppage (+ 28 192) "2.3 Symbolic Data")
;; (find-sicppage (+ 28 192) "2.3.1 Quotation")
;; (find-sicppage (+ 28 197) "2.3.2 Example: Symbolic Differentiation")
;; (find-sicppage (+ 28 205) "2.3.3 Example: Representing Sets")
;; (find-sicppage (+ 28 218) "2.3.4 Example: Huffman Encoding Trees")
;; (find-sicppage (+ 28 229) "2.4 Multiple Representations for Abstract Data")
;; (find-sicppage (+ 28 232) "2.4.1 Representations for Complex Numbers")
;; (find-sicppage (+ 28 237) "2.4.2 Tagged data")
;; (find-sicppage (+ 28 242) "2.4.3 Data-Directed Programming and Additivity")
;; (find-sicppage (+ 28 254) "2.5 Systems with Generic Operations")
;; (find-sicppage (+ 28 255) "2.5.1 Generic Arithmetic Operations")
;; (find-sicppage (+ 28 262) "2.5.2 Combining Data of Different Types")
;; (find-sicppage (+ 28 274) "2.5.3 Example: Symbolic Algebra")
;; (find-sicppage (+ 28 294) "3 Modularity, Objects, and State")
;; (find-sicppage (+ 28 296) "3.1 Assignment and Local State")
;; (find-sicppage (+ 28 297) "3.1.1 Local State Variables")
;; (find-sicppage (+ 28 305) "3.1.2 The Benefits of Introducing Assignment")
;; (find-sicppage (+ 28 311) "3.1.3 The Costs of Introducing Assignment")
;; (find-sicppage (+ 28 320) "3.2 The Environment Model of Evaluation")
;; (find-sicppage (+ 28 322) "3.2.1 The Rules for Evaluation")
;; (find-sicppage (+ 28 327) "3.2.2 Applying Simple Procedures")
;; (find-sicppage (+ 28 330) "3.2.3 Frames as the Repository of Local State")
;; (find-sicppage (+ 28 337) "3.2.4 Internal Definitions")
;; (find-sicppage (+ 28 341) "3.3 Modeling with Mutable Data")
;; (find-sicppage (+ 28 342) "3.3.1 Mutable List Structure")
;; (find-sicppage (+ 28 353) "3.3.2 Representing eues")
;; (find-sicppage (+ 28 360) "3.3.3 Representing Tables")
;; (find-sicppage (+ 28 369) "3.3.4 A Simulator for Digital Circuits")
;; (find-sicppage (+ 28 386) "3.3.5 Propagation of Constraints")
;; (find-sicppage (+ 28 401) "3.4 Concurrency: Time Is of the Essence")
;; (find-sicppage (+ 28 403) "3.4.1 The Nature of Time in Concurrent Systems")
;; (find-sicppage (+ 28 410) "3.4.2 Mechanisms for Controlling Concurrency")
;; (find-sicppage (+ 28 428) "3.5 Streams")
;; (find-sicppage (+ 28 430) "3.5.1 Streams Are Delayed Lists")
;; (find-sicppage (+ 28 441) "3.5.2 Infinite Streams")
;; (find-sicppage (+ 28 453) "3.5.3 Exploiting the Stream Paradigm")
;; (find-sicppage (+ 28 470) "3.5.4 Streams and Delayed Evaluation")
;; (find-sicppage (+ 28 479) "3.5.5 Modularity of Functional Programs and Modularity of Objects")
;; (find-sicppage (+ 28 487) "4 Metalinguistic Abstraction")
;; (find-sicppage (+ 28 492) "4.1 The Metacircular Evaluator")
;; (find-sicppage (+ 28 495) "4.1.1 The Core of the Evaluator")
;; (find-sicppage (+ 28 501) "4.1.2 Representing Expressions")
;; (find-sicppage (+ 28 512) "4.1.3 Evaluator Data Structures")
;; (find-sicppage (+ 28 518) "4.1.4 Running the Evaluator as a Program")
;; (find-sicppage (+ 28 522) "4.1.5 Data as Programs")
;; (find-sicppage (+ 28 526) "4.1.6 Internal Definitions")
;; (find-sicppage (+ 28 534) "4.1.7 Separating Syntactic Analysis from Execution")
;; (find-sicppage (+ 28 541) "4.2 Variations on a Scheme -- Lazy Evaluation")
;; (find-sicppage (+ 28 542) "4.2.1 Normal Order and Applicative Order")
;; (find-sicppage (+ 28 544) "4.2.2 An Interpreter with Lazy Evaluation")
;; (find-sicppage (+ 28 555) "4.2.3 Streams as Lazy Lists")
;; (find-sicppage (+ 28 559) "4.3 Variations on a Scheme -- Nondeterministic Computing")
;; (find-sicppage (+ 28 561) "4.3.1 Amb and Search")
;; (find-sicppage (+ 28 567) "4.3.2 Examples of Nondeterministic Programs")
;; (find-sicppage (+ 28 578) "4.3.3 Implementing the amb Evaluator")
;; (find-sicppage (+ 28 594) "4.4 Logic Programming")
;; (find-sicppage (+ 28 599) "4.4.1 Deductive Information Retrieval")
;; (find-sicppage (+ 28 615) "4.4.2 How the Query System Works")
;; (find-sicppage (+ 28 627) "4.4.3 Is Logic Programming Mathematical Logic?")
;; (find-sicppage (+ 28 635) "4.4.4 Implementing the ery System")
;; (find-sicppage (+ 28 636) "4.4.4.1 The Driver Loop and Instantiation")
;; (find-sicppage (+ 28 638) "4.4.4.2 The Evaluator")
;; (find-sicppage (+ 28 642) "4.4.4.3 Find Assertions by Pattern Matching")
;; (find-sicppage (+ 28 645) "4.4.4.4 Rules and Unification")
;; (find-sicppage (+ 28 651) "4.4.4.5 Maintaining the Data Base")
;; (find-sicppage (+ 28 654) "4.4.4.6 Stream Operations")
;; (find-sicppage (+ 28 656) "4.4.4.7 Query Syntax Procedures")
;; (find-sicppage (+ 28 659) "4.4.4.8 Frames and Bindings")
;; (find-sicppage (+ 28 666) "5 Computing with Register Maines")
;; (find-sicppage (+ 28 668) "5.1 Designing Register Machines")
;; (find-sicppage (+ 28 672) "5.1.1 A Language for Describing Register Machines")
;; (find-sicppage (+ 28 678) "5.1.2 Abstraction in Machine Design")
;; (find-sicppage (+ 28 681) "5.1.3 Subroutines")
;; (find-sicppage (+ 28 686) "5.1.4 Using a Stack to Implement Recursion")
;; (find-sicppage (+ 28 695) "5.1.5 Instruction Summary")
;; (find-sicppage (+ 28 696) "5.2 A Register-Machine Simulator")
;; (find-sicppage (+ 28 698) "5.2.1 The Machine Model")
;; (find-sicppage (+ 28 704) "5.2.2 The Assembler")
;; (find-sicppage (+ 28 708) "5.2.3 Generating Execution Procedures for Instructions")
;; (find-sicppage (+ 28 718) "5.2.4 Monitoring Machine Performance")
;; (find-sicppage (+ 28 723) "5.3 Storage Allocation and Garbage Collection")
;; (find-sicppage (+ 28 724) "5.3.1 Memory as Vectors")
;; (find-sicppage (+ 28 731) "5.3.2 Maintaining the Illusion of Infinite Memory")
;; (find-sicppage (+ 28 741) "5.4 The Explicit-Control Evaluator")
;; (find-sicppage (+ 28 743) "5.4.1 The Core of the Explicit-Control Evaluator")
;; (find-sicppage (+ 28 751) "5.4.2 Sequence Evaluation and Tail Recursion")
;; (find-sicppage (+ 28 756) "5.4.3 Conditionals, Assignments, and Definitions")
;; (find-sicppage (+ 28 759) "5.4.4 Running the Evaluator")
;; (find-sicppage (+ 28 767) "5.5 Compilation")
;; (find-sicppage (+ 28 772) "5.5.1 Structure of the Compiler")
;; (find-sicppage (+ 28 779) "5.5.2 Compiling Expressions")
;; (find-sicppage (+ 28 788) "5.5.3 Compiling Combinations")
;; (find-sicppage (+ 28 797) "5.5.4 Combining Instruction Sequences")
;; (find-sicppage (+ 28 802) "5.5.5 An Example of Compiled Code")
;; (find-sicppage (+ 28 817) "5.5.6 Lexical Addressing")
;; (find-sicppage (+ 28 823) "5.5.7 Interfacing Compiled Code to the Evaluator")
;; (find-sicppage (+ 28 834) "References")
;; (find-sicppage (+ 28 844) "List of Exercises")
;; (find-sicppage (+ 28 846) "List of Figures")
;; (find-sicppage (+ 28 848) "Index")
;; (find-sicppage (+ 28 855) "Colophon")
;; «aho» (to ".aho")
;; (find-books "__comp/__comp.el" "aho")
(code-pdf-page "dragonbook" "~/books/__comp/aho_lam_sethi_ullman__compilers_principles_techniques_and_tools__2nd_ed__6mb.pdf")
(code-pdf-text "dragonbook" "~/books/__comp/aho_lam_sethi_ullman__compilers_principles_techniques_and_tools__2nd_ed__6mb.pdf" 25)
(code-pdf-page "dragonbook" "~/books/__comp/aho_lam_sethi_ullman__compilers_principles_techniques_and_tools__2nd_ed__7mb.pdf")
(code-pdf-text "dragonbook" "~/books/__comp/aho_lam_sethi_ullman__compilers_principles_techniques_and_tools__2nd_ed__7mb.pdf")
;; (find-dragonbookpage)
;; (find-dragonbookpage 10 "Contents")
;; (find-dragonbooktext 10 "Contents")
;; (find-dragonbookpage (+ 25 7) "Figure 1.7: Translation of an assignment statement")
;; (find-dragonbooktext (+ 25 7) "Figure 1.7: Translation of an assignment statement")
;; (find-dragonbookpage (+ 25 30) "Figure 1.10: Blocks in a C++ program")
;; (find-dragonbooktext (+ 25 30) "Figure 1.10: Blocks in a C++ program")
;; (find-dragonbookpage (+ 25 41) "Figure 2.4: Intermediate code for")
;; (find-dragonbooktext (+ 25 41) "Figure 2.4: Intermediate code for")
;; (find-dragonbookpage (+ 25 47) "Figure 2.5: Parse tree for 9-5+2")
;; (find-dragonbooktext (+ 25 47) "Figure 2.5: Parse tree for 9-5+2")
;; (find-dragonbookpage (+ 25 48) "Figure 2.6: Two parse trees for 9-5+2")
;; (find-dragonbooktext (+ 25 48) "Figure 2.6: Two parse trees for 9-5+2")
;; (find-dragonbookpage (+ 25 993) "Index")
;; (find-dragonbooktext (+ 23 993) "Index")
;; (find-dragonbooktext "")
;; (find-dragonbookpage (+ 25 42) "2.2 Syntax Definition")
;; (find-dragonbookpage (+ 25 42) "2.2.1 Definition of Grammars")
;; (find-dragonbookpage (+ 25 44) "2.2.2 Derivations")
;; (find-dragonbookpage (+ 25 45) "2.2.3 Parse Trees")
;; (find-dragonbookpage (+ 25 47) "2.2.4 Ambiguity")
;; (find-dragonbookpage (+ 25 48) "2.2.5 Associativity of Operators")
;; (find-dragonbookpage (+ 25 48) "subtraction is left-associative")
;; (find-dragonbookpage (+ 25 48) "2.2.6 Precedence of Operators")
;; (find-dragonbookpage (+ 25 48) "* has higher precedence than +")
;; (find-dragonbookpage (+ 25 51) "2.2.7 Exercises for Section 2.2")
;; (find-dragonbookpage (+ 25 279) "4.8.1 Precedence and Associativity to Resolve Conflicts")
;; (find-dragonbookpage (+ 25 217) "4.4 Top-Down Parsing")
;; (find-dragonbookpage (+ 25 219) "4.4.1 Recursive-Descent Parsing")
;; (find-dragonbookpage (+ 25 220) "4.4.2 FIRST and FOLLOW")
;; (find-dragonbookpage (+ 25 222) "4.4.3 LL(1) Grammars")
;; (find-dragonbookpage (+ 25 226) "4.4.4 Nonrecursive Predictive Parsing")
;; (find-dragonbookpage (+ 25 228) "4.4.5 Error Recovery in Predictive Parsing")
;; (find-dragonbookpage (+ 25 231) "4.4.6 Exercises for Section 4.4")
;; (find-dragonbookpage (+ 25 233) "4.5 Bottom-Up Parsing")
;; (find-dragonbookpage (+ 25 234) "4.5.1 Reductions")
;; (find-dragonbookpage (+ 25 235) "4.5.2 Handle Pruning")
;; (find-dragonbookpage (+ 25 236) "4.5.3 Shift-Reduce Parsing")
;; (find-dragonbookpage (+ 25 238) "4.5.4 Conflicts During Shift-Reduce Parsing")
;; (find-dragonbookpage (+ 25 240) "4.5.5 Exercises for Section 4.5")
;; (find-dragonbookpage (+ 25 241) "4.6 Introduction to LR Parsing: Simple LR")
;; (find-dragonbookpage (+ 25 241) "4.6.1 Why LR Parsers?")
;; (find-dragonbookpage (+ 25 242) "4.6.2 Items and the LR(0) Automaton")
;; (find-dragonbookpage (+ 25 248) "4.6.3 The LR-Parsing Algorithm")
;; (find-dragonbookpage (+ 25 252) "4.6.4 Constructing SLR-Parsing Tables")
;; (find-dragonbookpage (+ 25 256) "4.6.5 Viable Prefixes")
;; (find-dragonbookpage (+ 25 257) "4.6.6 Exercises for Section 4.6")
;; (find-dragonbookpage (+ 25 259) "4.7 More Powerful LR Parsers")
;; (find-dragonbookpage (+ 25 260) "4.7.1 Canonical LR(1) Items")
;; (find-dragonbookpage (+ 25 261) "4.7.2 Constructing LR(1) Sets of Items")
;; (find-dragonbookpage (+ 25 265) "4.7.3 Canonical LR(1) Parsing Tables")
;; (find-dragonbookpage (+ 25 266) "4.7.4 Constructing LALR Parsing Tables")
;; (find-dragonbookpage (+ 25 270) "4.7.5 Efficient Construction of LALR Parsing Tables")
;; (find-dragonbookpage (+ 25 275) "4.7.6 Compaction of LR Parsing Tables")
;; (find-dragonbookpage (+ 25 277) "4.7.7 Exercises for Section 4.7")
;; «allen» (to ".allen")
;; http://gigapedia.com/items/302606/anatomy-of-lisp--mcgraw-hill-computer-science-series-
(code-djvu "anatomyoflisp" "~/books/__comp/allen__anatomy_of_lisp.djvu")
;; (find-anatomyoflisppage 6 "Contents")
;; (find-anatomyoflisppage (+ 17 443) "Index")
;; «augustsson» (to ".augustsson")
;; (find-books "__comp/__comp.el" "augustsson")
;; Lennart Augustsson: "Equality proofs in Cayenne"
;; https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.37.9415
(code-pdf-page "aepic" "~/books/__comp/augustsson__equality_proofs_in_cayenne.pdf")
(code-pdf-text "aepic" "~/books/__comp/augustsson__equality_proofs_in_cayenne.pdf" 1)
;; (find-aepicpage)
;; (find-aepictext "")
;; (find-aepicpage 2 "={ DEF }=")
;; (find-aepictext 2 "={ DEF }=")
;; «baker» (to ".baker")
;; "Linear Logic and Permutation Stacks - The Forth Shall Be First"
;; https://dl.acm.org/doi/10.1145/181993.181999
;; http://home.pipeline.com/~hbaker1/ForthStack.html
;; «barras» (to ".barras")
;; http://www.lix.polytechnique.fr/Labo/Bruno.Barras/publis.html
;; http://www.lix.polytechnique.fr/Labo/Bruno.Barras/publi/these_barras.pdf
(code-pdf-page "barras" "$S/http/www.lix.polytechnique.fr/Labo/Bruno.Barras/publi/these_barras.pdf")
(code-pdf-text "barras" "$S/http/www.lix.polytechnique.fr/Labo/Bruno.Barras/publi/these_barras.pdf")
;; (find-barraspage)
;; (find-barrastext)
;; (find-barraspage 5 "Table des matières")
;; (find-barrastext 5 "Table des matières")
;; (find-barraspage 116 "4.5 Les PTS Cumulatifs (CTS)")
;; (find-barrastext 116 "4.5 Les PTS Cumulatifs (CTS)")
;; «barski» (to ".barski")
(code-xpdf "barski" "~/books/__comp/barski__land_of_lisp.pdf")
(code-pdftotext "barski" "~/books/__comp/barski__land_of_lisp.pdf")
;; (find-barskipage 1 "Contents")
;; (find-barskipage (+ 1 1) "Index")
;; (find-barskitext "")
;; «bentley» (to ".bentley")
;; «bentley-pp» (to ".bentley-pp")
;; (find-books "__comp/__comp.el" "bentley-pp")
(code-pdf-page "bentleypp" "~/books/__comp/bentley__programming_pearls.pdf")
(code-pdf-text "bentleypp" "~/books/__comp/bentley__programming_pearls.pdf" 1)
;; (find-bentleypppage)
;; (find-bentleypppage 7 "Contents")
;; (find-bentleypppage (+ 8 1) "Part I: Preliminaries")
;; (find-bentleypppage (+ 7 3) "1.")
;; (find-bentleypppage (+ 7 11) "2. Aha")
;; (find-bentleypppage (+ 6 23) "3. Data structures programs")
;; (find-bentleypppage (+ 6 35) "4. Writing correct programs")
;; (find-bentleypppage (+ 6 49) "Part II: Performance")
;; (find-bentleypppage (+ 6 51) "5. Perspective on performance")
;; (find-bentleypppage (+ 5 59) "6. The back")
;; (find-bentleypppage (+ 5 69) "7. Algorithm design techniques")
;; (find-bentleypppage (+ 5 81) "8. Code tuning")
;; (find-bentleypppage (+ 5 93) "9. Squeezing space")
;; (find-bentleypppage (+ 5 105) "Part III: The product")
;; (find-bentleypppage (+ 4 107) "10. Sorting")
;; (find-bentleypppage (+ 4 117) "11. Searching")
;; (find-bentleypppage (+ 4 125) "12. Heaps")
;; (find-bentleypppage (+ 3 139) "13: A Spelling Checker" "translit A-Z a-z |")
;; (find-bentleypppage (+ 3 151) "Epilog")
;; (find-bentleypppage (+ 2 155) "Catalog of algorithms")
;; (find-bentleypppage (+ 2 159) "Hints for selected problems")
;; (find-bentleypppage (+ 2 163) "Solutions to selected problems")
;; (find-bentleypppage (+ 1 189) "Index")
;; (find-bentleypptext "")
;; «bentley-morepp» (to ".bentley-morepp")
(code-djvu "bentleympp" "~/books/__comp/bentley__more_programming_pearls__confessions_of_a_coder.djvu")
(code-djvutotext "bentleympp" "~/books/__comp/bentley__more_programming_pearls__confessions_of_a_coder.djvu" 2)
(code-pdf-page "bentleympp" "~/books/__comp/bentley__more_programming_pearls__confessions_of_a_coder.pdf")
(code-pdf-text "bentleympp" "~/books/__comp/bentley__more_programming_pearls__confessions_of_a_coder.pdf" 2)
;; (find-bentleympppage 6 "Contents")
;; (find-bentleympppage (+ 0 83) "9. Little Languages")
;; (find-bentleympppage (+ 0 92) "Lynn Jelinski")
;; (find-bentleympptext "Lynn Jelinski")
;; (find-bentleympppage (+ -1 203) "Index")
;; (find-bentleympptext "")
;; «bernardy-lasson» (to ".bernardy-lasson")
;; (find-books "__comp/__comp.el" "bernardy-lasson")
;; Bernardy/Lasson: "Realizability and Parametricity in Pure Type Systems"
;; https://link.springer.com/chapter/10.1007/978-3-642-19805-2_8
(code-pdf-page "blrapipts" "~/books/__comp/bernardy_lasson__realizability_and_parametricity_in_pure_type_systems.pdf")
(code-pdf-text "blrapipts" "~/books/__comp/bernardy_lasson__realizability_and_parametricity_in_pure_type_systems.pdf" 1)
;; (find-blrapiptspage)
;; (find-blrapiptspage 1 "Contents")
;; (find-blrapiptspage (+ 1 189) "Index")
;; (find-blrapiptstext "")
;; «bernardy-jansson-paterson» (to ".bernardy-jansson-paterson")
;; (find-books "__comp/__comp.el" "bernardy-jansson-paterson")
;; Bernardy/Jansson/Paterson: "Proofs for free: Parametricity for dependent types" (2012)
;; https://doi.org/10.1017/S0956796812000056
(code-pdf-page "bjpproofsforfree" "~/books/__comp/bernardy_jansson_paterson__proofs_for_free_parametricity_for_dependent_types.pdf")
(code-pdf-text "bjpproofsforfree" "~/books/__comp/bernardy_jansson_paterson__proofs_for_free_parametricity_for_dependent_types.pdf" 1)
;; (find-bjpproofsforfreepage)
;; (find-bjpproofsforfreepage 1 "Contents")
;; (find-bjpproofsforfreepage (+ 1 189) "Index")
;; (find-bjpproofsforfreetext "")
;; «blauth» (to ".blauth")
(code-xpdf "blauthmd" "~/books/__comp/menezes__matematica_discreta_para_computacao_e_informatica.pdf")
;; (find-blauthmdpage 7 "Contents")
;; (find-blauthmdpage (+ -117 251) "Index")
;; «bournez» (to ".bournez")
;; (find-books "__comp/__comp.el" "bournez")
;; https://www.sciencedirect.com/journal/journal-of-complexity/vol/23/issue/3
;; https://www.sciencedirect.com/science/article/pii/S0885064X07000246
(code-pdf-page "bournezpdec" "~/books/__comp/bournez_et_al__polynomial_differential_equations_compute_all_real_computable_functions_on_computable_compact_intervals.pdf")
(code-pdf-text "bournezpdec" "~/books/__comp/bournez_et_al__polynomial_differential_equations_compute_all_real_computable_functions_on_computable_compact_intervals.pdf" 1)
;; (find-bournezpdecpage)
;; (find-bournezpdecpage 1 "Contents")
;; (find-bournezpdecpage (+ 1 189) "Index")
;; (find-bournezpdectext "")
;; «brady» (to ".brady")
;; (find-books "__comp/__comp.el" "brady")
;; (find-angg ".emacs" "idris-bradytdd")
(code-pdf-page "bradytdd" "~/books/__comp/brady__type-driven_development_with_idris.pdf")
(code-pdf-text "bradytdd" "~/books/__comp/brady__type-driven_development_with_idris.pdf" 26)
;; (find-bradytddpage)
;; (find-bradytddpage 7 "Contents")
;; (find-bradytddtext 7 "Contents")
;; (find-bradytddpage 23 "https://github.com/edwinb/")
;; (find-bradytddtext 23 "https://github.com/edwinb/")
;; (find-bradytddpage (+ 26 1) "PART 1: INTRODUCTION")
;; (find-bradytddpage (+ 26 3) "1 Overview")
;; (find-bradytddpage (+ 26 11) "AnyList")
;; (find-bradytddtext (+ 26 11) "AnyList")
;; (find-bradytddpage (+ 26 17) "1.4.1 The interactive environment")
;; (find-bradytddtext (+ 26 17) "1.4.1 The interactive environment")
;; (find-bradytddpage (+ 26 18) "Type : Type 1")
;; (find-bradytddtext (+ 26 18) "Type : Type 1")
;; (find-bradytddpage (+ 26 19) "1.4.3 Compiling and running Idris programs")
;; (find-bradytddtext (+ 26 19) "1.4.3 Compiling and running Idris programs")
;; (find-bradytddpage (+ 26 20) "idris Hello.idr -o Hello")
;; (find-bradytddtext (+ 26 20) "idris Hello.idr -o Hello")
;; (find-bradytddpage (+ 26 20) "1.4.4 Incomplete definitions: working with holes")
;; (find-bradytddtext (+ 26 20) "1.4.4 Incomplete definitions: working with holes")
;; (find-bradytddpage (+ 26 21) "reload Hello.idr with the :r")
;; (find-bradytddtext (+ 26 21) "reload Hello.idr with the :r")
;; (find-bradytddpage (+ 26 22) "Calculating a type")
;; (find-bradytddtext (+ 26 22) "Calculating a type")
;; (find-bradytddpage (+ 26 25) "2 Getting started with Idris")
;; (find-bradytddpage (+ 26 45) "Modules and namespaces")
;; (find-bradytddtext (+ 26 45) "Modules and namespaces")
;; (find-bradytddpage (+ 26 53) "PART 2: CORE IDRIS")
;; (find-bradytddpage (+ 26 55) "3 Interactive development with types")
;; (find-bradytddpage (+ 26 87) "4 User-defined data types")
;; (find-bradytddpage (+ 26 123) "5 Interactive programs: input and output processing")
;; (find-bradytddpage (+ 26 147) "6 Programming with first-class types")
;; (find-bradytddpage (+ 26 182) "7 Interfaces: using constrained generic types")
;; (find-bradytddpage (+ 26 208) "8 Equality: expressing relationships between data")
;; (find-bradytddpage (+ 26 236) "9 Predicates: expressing assumptions and contracts in types")
;; (find-bradytddpage (+ 26 258) "10 Views: extending pattern matching")
;; (find-bradytddpage (+ 26 289) "PART 3: IDRIS AND THE REAL WORLD")
;; (find-bradytddpage (+ 26 291) "11 Streams and processes: working with infinite data")
;; (find-bradytddpage (+ 26 324) "12 Writing programs with state")
;; (find-bradytddpage (+ 26 352) "13 State machines: verifying protocols in types")
;; (find-bradytddpage (+ 26 373) "14 Dependent state machines: handling feedback and errors")
;; (find-bradytddpage (+ 26 403) "15 Type-safe concurrent programming")
;; (find-bradytddtext "")
;; «buzzard-wp» (to ".buzzard-wp")
;; (find-books "__comp/__comp.el" "buzzard-wp")
;; https://arxiv.org/abs/2112.11598
;; https://arxiv.org/pdf/2112.11598.pdf
;; https://www.imperial.ac.uk/people/k.buzzard
;; http://wwwf.imperial.ac.uk/~buzzard/
;; "What is the point of computers? A question for pure mathematicians" (2020)
(code-pdf-page "buzzardwp" "$S/https/arxiv.org/pdf/2112.11598.pdf")
(code-pdf-text "buzzardwp" "$S/https/arxiv.org/pdf/2112.11598.pdf")
;; (find-buzzardwppage)
;; (find-buzzardwptext)
;; (find-buzzardwppage 9 "De Bruijn factor")
;; (find-buzzardwptext 9 "De Bruijn factor")
;; https://www.ma.ic.ac.uk/~buzzard/xena/pdfs/grothendieck_equality.pdf
;; «chan-windmill» (to ".chan-windmill")
;; (find-books "__comp/__comp.el" "chan-windmill")
;; (find-es "tikz" "chan-windmill")
;; https://arxiv.org/abs/2112.02556
;; https://arxiv.org/pdf/2112.02556.pdf
;; Windmills of the Minds: An Algorithm for Fermat's Two Squares Theorem
(code-pdf-page "chanwindmill" "$S/https/arxiv.org/pdf/2112.02556.pdf")
(code-pdf-text "chanwindmill" "$S/https/arxiv.org/pdf/2112.02556.pdf")
;; (find-chanwindmillpage)
;; (find-chanwindmilltext)
;; «chapman» (to ".chapman")
;; (find-books "__comp/__comp.el" "chapman")
;; (find-books "__comp/__comp.el" "norell")
;; https://jmchapman.io/papers/funandprofit.pdf
;; https://jmchapman.io/papers/lfmtp08_jmc.pdf
;; «chapman-systemF» (to ".chapman-systemF")
;; (find-es "agda" "system-F-in-agda")
;; (find-books "__comp/__comp.el" "chapman-systemF")
;; https://homepages.inf.ed.ac.uk/wadler/papers/mpc-2019/system-f-in-agda.pdf
(code-pdf-page "systemFinagda" "$S/https/homepages.inf.ed.ac.uk/wadler/papers/mpc-2019/system-f-in-agda.pdf")
(code-pdf-text "systemFinagda" "$S/https/homepages.inf.ed.ac.uk/wadler/papers/mpc-2019/system-f-in-agda.pdf")
;; (find-systemFinagdapage)
;; (find-systemFinagdatext)
;; «chlipala» (to ".chlipala")
;; (find-books "__comp/__comp.el" "chlipala")
;; (find-LATEX "catsem-u.bib" "bib-Chlipala")
;; https://arxiv.org/pdf/1401.7694.pdf
;; https://arxiv.org/abs/1401.7694
;; Gross, Chlipala and Spivak: "Experience Implementing a Performant Category-Theory Library in Coq"
(code-pdf "perfctcoq" "~/books/__comp/gross_chlipala_spivak__experience_implementing_a_performant_category-theory_library_in_coq.pdf")
(code-pdftotext "perfctcoq" "~/books/__comp/gross_chlipala_spivak__experience_implementing_a_performant_category-theory_library_in_coq.pdf" 1)
;; (find-perfctcoqpage)
;; (find-perfctcoqpage 4 "Record Category")
;; (find-perfctcoqtext 4 "Record Category")
;; (find-perfctcoqpage (+ 1 189) "Index")
;; (find-perfctcoqtext "")
;; Parameterized Higher Order Abstract Syntax
;; https://cstheory.stackexchange.com/questions/45924/phoas-with-extrinsic-typing
;; http://adam.chlipala.net/papers/PhoasICFP08/
;; http://adam.chlipala.net/papers/PhoasICFP08/PhoasICFP08.pdf
;; http://adam.chlipala.net/papers/ImpurePOPL10/
;; «choudhury-krishnaswami» (to ".choudhury-krishnaswami")
;; (find-books "__comp/__comp.el" "choudhury-krishnaswami")
;; https://mail.google.com/mail/ca/u/0/#inbox/FMfcgxwHNCspzbpqktBfnCdvvfkGZwXx
;; Choudhury/Krishnaswami:
;; "Recovering Purity with Comonads and Capabilities: The marriage of purity and comonads"
;; https://arxiv.org/abs/1907.07283
;; https://arxiv.org/pdf/1907.07283.pdf
(code-pdf-page "recopucoca" "$S/https/arxiv.org/pdf/1907.07283.pdf")
(code-pdf-text "recopucoca" "$S/https/arxiv.org/pdf/1907.07283.pdf")
;; (find-recopucocapage)
;; (find-recopucocatext)
;; «colton» (to ".colton")
;; (find-books "__comp/__comp.el" "colton")
;; https://axon.cs.byu.edu/~dan/673/papers/colton.math.pdf
(code-pdf-page "colton" "$S/https/axon.cs.byu.edu/~dan/673/papers/colton.math.pdf")
(code-pdf-text "colton" "$S/https/axon.cs.byu.edu/~dan/673/papers/colton.math.pdf")
;; (find-coltonpage)
;; (find-coltontext)
;; (find-coltonpage 11 "Principia Mathematica")
;; (find-coltontext 11 "Principia Mathematica")
;; «coquand» (to ".coquand")
;; (find-books "__comp/__comp.el" "coquand")
;; Thierry Coquand 1992: "Pattern Matching with Dependent Types"
;; https://wonks.github.io/type-theory-reading-group/
;; https://wonks.github.io/type-theory-reading-group/papers/proc92-coquand.pdf
(code-pdf-page "coquandpmdt" "$S/https/wonks.github.io/type-theory-reading-group/papers/proc92-coquand.pdf")
(code-pdf-text "coquandpmdt" "$S/https/wonks.github.io/type-theory-reading-group/papers/proc92-coquand.pdf")
;; (find-coquandpmdtpage)
;; (find-coquandpmdttext)
;; «crockford» (to ".crockford")
;; (to "javascript")
;; «dershowitz-gurevich» (to ".dershowitz-gurevich")
;; (find-books "__comp/__comp.el" "dershowitz-gurevich")
;; (find-angg ".emacs.papers" "gurevich")
;; https://philpapers.org/rec/DERANA
(code-pdf "gurevchurch" "~/books/__comp/dershowitz_gurevich__proof_of_curch_s_thesis.pdf")
(code-pdftotext "gurevchurch" "~/books/__comp/dershowitz_gurevich__proof_of_curch_s_thesis.pdf" 1)
;; (find-gurevchurchpage)
;; (find-gurevchurchpage 1 "Contents")
;; (find-gurevchurchpage (+ 1 189) "Index")
;; (find-gurevchurchtext "")
;; «dijkstra» (to ".dijkstra")
;; (find-books "__comp/__comp.el" "dijkstra")
(code-pdf-page "dijkstradip" "~/books/__comp/dijkstra__a_discipline_of_programming.pdf")
(code-pdf-text "dijkstradip" "~/books/__comp/dijkstra__a_discipline_of_programming.pdf" 1)
;; (find-dijkstradippage)
;; (find-dijkstradippage 4 "Contents")
;; (find-dijkstradippage (+ 15 111) "14. The problem of the Dutch national flag")
;; (find-dijkstradiptext "")
;; «dreyer» (to ".dreyer")
;; (find-books "__comp/__comp.el" "dreyer")
;; https://people.mpi-sws.org/~dreyer/
;; https://people.mpi-sws.org/~dreyer/teaching.html
;; https://courses.ps.uni-saarland.de/sem_ws1920/ Semantics
;; https://courses.ps.uni-saarland.de/sem_ws1920/3/Resources
;; Parametricity and Modular Reasoning (course - lots of material):
;; https://wiki.mpi-sws.org/star/paramore
;; «dsls-of-math» (to ".dsls-of-math")
;; (find-es "math" "dslsofmath")
;; (find-books "__comp/__comp.el" "dsls-of-math")
(code-pdf-page "dslsofmath" "$S/https/github.com/DSLsofMath/DSLsofMath/raw/master/L/snapshots/DSLsofMathBook_snapshot_2022-01-06.pdf")
(code-pdf-text "dslsofmath" "$S/https/github.com/DSLsofMath/DSLsofMath/raw/master/L/snapshots/DSLsofMathBook_snapshot_2022-01-06.pdf" 6)
;; (find-dslsofmathpage)
;; (find-dslsofmathtext)
;; (find-dslsofmathpage (+ 6 1) "About this book")
;; (find-dslsofmathpage (+ 6 1) "0.1 Origins")
;; (find-dslsofmathpage (+ 6 4) "0.2 Who should read this book?")
;; (find-dslsofmathpage (+ 6 5) "0.3 Notation and code convention")
;; (find-dslsofmathpage (+ 6 6) "0.4 Acknowledgments")
;; (find-dslsofmathpage (+ 6 7) "1 Types, Functions, and DSLs for Expressions")
;; (find-dslsofmathpage (+ 6 8) "1.1 Types of data and functions")
;; (find-dslsofmathpage (+ 6 14) "1.2 Types in Haskell: type, newtype, and data")
;; (find-dslsofmathpage (+ 6 16) "1.3 Notation and abstract syntax for sequences")
;; (find-dslsofmathpage (+ 6 18) "1.4 A DSL of complex numbers")
;; (find-dslsofmathpage (+ 6 24) "1.5 A syntax for (complex) arithmetical expressions")
;; (find-dslsofmathpage (+ 6 26) "1.6 Laws, properties and testing")
;; (find-dslsofmathpage (+ 6 29) "1.7 Types of functions, expressions and operators")
;; (find-dslsofmathpage (+ 6 37) "1.8 Exercises: Haskell, DSLs and expressions")
;; (find-dslsofmathpage (+ 6 43) "2 DSLs for logic and proofs")
;; (find-dslsofmathpage (+ 6 43) "2.1 Propositional Calculus")
;; (find-dslsofmathpage (+ 6 57) "2.2 First Order Logic")
;; (find-dslsofmathpage (+ 6 64) "2.3 An aside: Pure set theory")
;; (find-dslsofmathpage (+ 6 66) "2.4 Example proofs: contradiction, cases, primes")
;; (find-dslsofmathpage (+ 6 69) "2.5 Basic concepts of calculus")
;; (find-dslsofmathpage (+ 6 75) "2.6 Exercises")
;; (find-dslsofmathpage (+ 6 81) "3 Types in Mathematics")
;; (find-dslsofmathpage (+ 6 81) "3.1 Typing Mathematics: derivative of a function")
;; (find-dslsofmathpage (+ 6 82) "3.2 Typing Mathematics: partial derivative")
;; (find-dslsofmathpage (+ 6 84) "hard to rename variables")
;; (find-dslsofmathtext (+ 6 84) "hard to rename variables")
;; (find-dslsofmathpage (+ 6 85) "3.3 Typing Mathematics: Lagrangian case study")
;; (find-dslsofmathpage (+ 6 88) "3.4 Incremental analysis with types")
;; (find-dslsofmathpage (+ 6 90) "3.5 Type classes")
;; (find-dslsofmathpage (+ 6 95) "3.6 Computing derivatives")
;; (find-dslsofmathpage (+ 6 98) "3.7 Exercises")
;; (find-dslsofmathpage (+ 6 101) "4 Compositionality and Algebras")
;; (find-dslsofmathpage (+ 6 102) "4.1 Algebraic Structures")
;; (find-dslsofmathpage (+ 6 105) "4.2 Homomorphisms")
;; (find-dslsofmathpage (+ 6 109) "4.3 Compositional semantics")
;; (find-dslsofmathpage (+ 6 111) "4.4 Folds")
;; (find-dslsofmathpage (+ 6 116) "4.5 Initial and Free Structures")
;; (find-dslsofmathpage (+ 6 122) "4.6 Computing derivatives, reprise")
;; (find-dslsofmathpage (+ 6 126) "4.7 Summary")
;; (find-dslsofmathpage (+ 6 128) "4.8 Beyond Algebras: Co-algebra and the Stream calculus")
;; (find-dslsofmathpage (+ 6 129) "4.9 A solved exercise")
;; (find-dslsofmathpage (+ 6 134) "4.10 Exercises")
;; (find-dslsofmathpage (+ 6 141) "5 Polynomials and Power Series")
;; (find-dslsofmathpage (+ 6 141) "5.1 Polynomials")
;; (find-dslsofmathpage (+ 6 147) "5.2 Division and the degree of the zero polynomial")
;; (find-dslsofmathpage (+ 6 148) "5.3 Polynomial degree as a homomorphism")
;; (find-dslsofmathpage (+ 6 149) "5.4 Power Series")
;; (find-dslsofmathpage (+ 6 152) "5.5 Operations on power series")
;; (find-dslsofmathpage (+ 6 153) "5.6 Formal derivative")
;; (find-dslsofmathpage (+ 6 155) "5.7 Exercises")
;; (find-dslsofmathpage (+ 6 158) "6 Taylor and Maclaurin series")
;; (find-dslsofmathpage (+ 6 161) "6.1 Taylor series")
;; (find-dslsofmathpage (+ 6 164) "6.2 Derivatives and Integrals for Maclaurin series")
;; (find-dslsofmathpage (+ 6 164) "6.3 Integral for Formal Power series")
;; (find-dslsofmathpage (+ 6 165) "6.4 Simple differential equations")
;; (find-dslsofmathpage (+ 6 168) "6.5 Exponentials and trigonometric functions")
;; (find-dslsofmathpage (+ 6 170) "6.6 Associated code")
;; (find-dslsofmathpage (+ 6 172) "6.7 Exercises")
;; (find-dslsofmathpage (+ 6 175) "7 Elements of Linear Algebra")
;; (find-dslsofmathpage (+ 6 178) "7.1 Representing vectors as functions")
;; (find-dslsofmathpage (+ 6 181) "7.2 Linear transformations")
;; (find-dslsofmathpage (+ 6 184) "7.3 Inner products")
;; (find-dslsofmathpage (+ 6 186) "7.4 Examples of matrix algebra")
;; (find-dslsofmathpage (+ 6 197) "7.5 *Monadic dynamical systems")
;; (find-dslsofmathpage (+ 6 200) "7.6 Associated code")
;; (find-dslsofmathpage (+ 6 202) "7.7 Exercises")
;; (find-dslsofmathpage (+ 6 204) "8 Exponentials and Laplace")
;; (find-dslsofmathpage (+ 6 204) "8.1 The Exponential Function")
;; (find-dslsofmathpage (+ 6 209) "8.2 The Laplace transform")
;; (find-dslsofmathpage (+ 6 216) "8.3 Laplace and other transforms")
;; (find-dslsofmathpage (+ 6 217) "8.4 Exercises")
;; (find-dslsofmathpage (+ 6 219) "9 Probability Theory")
;; (find-dslsofmathpage (+ 6 220) "9.1 Sample spaces")
;; (find-dslsofmathpage (+ 6 223) "9.2 *Monad Interface")
;; (find-dslsofmathpage (+ 6 223) "9.3 Distributions")
;; (find-dslsofmathpage (+ 6 225) "9.4 Semantics of spaces")
;; (find-dslsofmathpage (+ 6 228) "9.5 Random Variables")
;; (find-dslsofmathpage (+ 6 230) "9.6 Events and probability")
;; (find-dslsofmathpage (+ 6 234) "9.7 Examples: Dice, Drugs, Monty Hall")
;; (find-dslsofmathpage (+ 6 237) "9.8 *Solving a problem with equational reasoning")
;; (find-dslsofmathpage (+ 6 242) "A The course "DSLs of Mathematics"")
;; (find-dslsofmathpage (+ 6 245) "B Parameterised Complex Numbers")
;; «dybjer» (to ".dybjer")
;; (find-books "__comp/__comp.el" "dybjer")
;; (find-es "coq" "CIC")
;; http://www.cse.chalmers.se/~peterd/
;; http://www.cse.chalmers.se/~peterd/papers/inductive.html
;; https://plato.stanford.edu/entries/type-theory-intuitionistic/
;;
;; «dybjer-dtaw» (to ".dybjer-dtaw")
;; (find-books "__comp/__comp.el" "dybjer-dtaw")
;; http://www.cse.chalmers.se/~peterd/papers/DependentTypesAtWork.pdf
(code-pdf-page "dybjerdtaw" "$S/http/www.cse.chalmers.se/~peterd/papers/DependentTypesAtWork.pdf")
(code-pdf-text "dybjerdtaw" "$S/http/www.cse.chalmers.se/~peterd/papers/DependentTypesAtWork.pdf")
;; (find-dybjerdtawpage)
;; (find-dybjerdtawtext)
;; (find-dybjerdtawpage 8 "id : (A : Set) -> A -> A")
;; (find-dybjerdtawtext 8 "id : (A : Set) -> A -> A")
;;
;; http://www.cse.chalmers.se/~peterd/papers/MartinLofFestschrift.pdf
(code-pdf-page "dybjermlfest" "$S/http/www.cse.chalmers.se/~peterd/papers/MartinLofFestschrift.pdf")
(code-pdf-text "dybjermlfest" "$S/http/www.cse.chalmers.se/~peterd/papers/MartinLofFestschrift.pdf")
;; (find-dybjermlfestpage)
;; (find-dybjermlfesttext)
;;
;; "Inductive familes" (1997)
;; http://www.cse.chalmers.se/~peterd/papers/Inductive_Families.pdf
(code-pdf-page "dybjerindfams" "$S/http/www.cse.chalmers.se/~peterd/papers/Inductive_Families.pdf")
(code-pdf-text "dybjerindfams" "$S/http/www.cse.chalmers.se/~peterd/papers/Inductive_Families.pdf")
;; (find-dybjerindfamspage)
;; (find-dybjerindfamspage 6 "3. A scheme for inductive definitions")
;; (find-dybjerindfamspage 6 "3.1.2. Examples")
;; (find-dybjerindfamstext)
;;
;; "Representing inductively defined sets by wellorderings in Martin-Löf's Type Theory"
;; http://www.cse.chalmers.se/~peterd/papers/Wellorderings.pdf
(code-pdf-page "dybjerwo" "$S/http/www.cse.chalmers.se/~peterd/papers/Wellorderings.pdf")
(code-pdf-text "dybjerwo" "$S/http/www.cse.chalmers.se/~peterd/papers/Wellorderings.pdf")
;; (find-dybjerwopage)
;; (find-dybjerwotext)
;;
;; "A Finite Axiomatization of Inductive-Recursive Definitions" (1999)
;; http://www.cse.chalmers.se/~peterd/papers/Finite_IR.pdf
(code-pdf-page "dybjerfir" "$S/http/www.cse.chalmers.se/~peterd/papers/Finite_IR.pdf")
(code-pdf-text "dybjerfir" "$S/http/www.cse.chalmers.se/~peterd/papers/Finite_IR.pdf")
;; (find-dybjerfirpage)
;; (find-dybjerfirtext)
;;
;; «dybjer-paulin» (to ".dybjer-paulin")
;; http://www.cse.chalmers.se/~peterd/slides/PaulinHonorary2011.pdf (slides, 2011)
(code-pdf-page "dybjerpaulinh" "$S/http/www.cse.chalmers.se/~peterd/slides/PaulinHonorary2011.pdf")
(code-pdf-text "dybjerpaulinh" "$S/http/www.cse.chalmers.se/~peterd/slides/PaulinHonorary2011.pdf")
;; (find-dybjerpaulinhpage)
;; (find-dybjerpaulinhtext)
;; «eisenberg» (to ".eisenberg")
;; (find-books "__comp/__comp.el" "eisenberg")
;; https://wonks.github.io/type-theory-reading-group/
;; https://www.cis.upenn.edu/~sweirich/papers/eisenberg-thesis.pdf
;; Richard A. Eisenberg: "Dependent Types in Haskell: Theory and Practice" (PhD Thesis)
(code-pdf-page "eisenbergphd" "$S/https/www.cis.upenn.edu/~sweirich/papers/eisenberg-thesis.pdf")
(code-pdf-text "eisenbergphd" "$S/https/www.cis.upenn.edu/~sweirich/papers/eisenberg-thesis.pdf" 15)
;; (find-eisenbergphdpage)
;; (find-eisenbergphdtext)
;; (find-eisenbergphdpage 7 "Contents")
;; (find-eisenbergphdtext 7 "Contents")
;; (find-eisenbergphdpage (+ 15 51) "Chapter 4" "Dependent Haskell")
;; (find-eisenbergphdtext (+ 15 51) "Chapter 4" "Dependent Haskell")
;; «ellis-ritchie» (to ".ellis-ritchie")
;; (find-books "__comp/__comp.el" "ellis-ritchie")
;; https://web.mit.edu/ellisk/www/
;; https://people.csail.mit.edu/asolar/
;;
;; Ellis/Ritchie/Solar-Lezama/Tenenbaum: "Learning to Infer Graphics Programs from Hand-Drawn Images"
;; https://papers.nips.cc/paper/7845-learning-to-infer-graphics-programs-from-hand-drawn-images
;; https://papers.nips.cc/paper/7845-learning-to-infer-graphics-programs-from-hand-drawn-images.pdf
;; https://papers.nips.cc/paper/7845-learning-to-infer-graphics-programs-from-hand-drawn-images-supplemental.zip
;; (find-fline "$S/https/papers.nips.cc/paper/")
;; (find-sh0 "cd $S/https/papers.nips.cc/paper/ && unzip -o 7845-*.zip")
;; https://papers.nips.cc/paper/supplement.pdf
;; https://media.nips.cc/nipsbooks/nipspapers/paper_files/nips31/reviews/2974.html
(code-pdf-page "ligpfromhand" "$S/https/papers.nips.cc/paper/7845-learning-to-infer-graphics-programs-from-hand-drawn-images.pdf")
(code-pdf-text "ligpfromhand" "$S/https/papers.nips.cc/paper/7845-learning-to-infer-graphics-programs-from-hand-drawn-images.pdf")
(code-pdf-page "ligpfromhandsup" "$S/https/papers.nips.cc/paper/supplement.pdf")
(code-pdf-text "ligpfromhandsup" "$S/https/papers.nips.cc/paper/supplement.pdf")
;; (find-ligpfromhandpage)
;; (find-ligpfromhandtext)
;; (find-ligpfromhandsuppage)
;; (find-ligpfromhandsuptext)
;; «escardo» (to ".escardo")
;; https://www.cs.bham.ac.uk/~mhe/
;; https://www.cs.bham.ac.uk/~mhe/.talks/types2011/omniscient.pdf
;; «fleuriot» (to ".fleuriot")
;; (find-books "__comp/__comp.el" "fleuriot")
;; https://lawrencecpaulson.github.io/2023/11/01/Foundations.html
;; https://lawrencecpaulson.github.io/2022/08/10/Nonstandard_Analysis.html
;; https://homepages.inf.ed.ac.uk/jdf/
(code-pdf-page "fleuriot" "~/books/__comp/fleuriot__a_combination_of_geometry_theorem_proving_and_nonstandard_analysis_with_application_to_newton_s_principia.pdf")
(code-pdf-text "fleuriot" "~/books/__comp/fleuriot__a_combination_of_geometry_theorem_proving_and_nonstandard_analysis_with_application_to_newton_s_principia.pdf" 1)
;; (find-fleuriotpage)
;; (find-fleuriotpage 1 "Contents")
;; (find-fleuriotpage (+ 1 189) "Index")
;; (find-fleuriottext "")
;; «gavranovic» (to ".gavranovic")
;; https://www.brunogavranovic.com/
;; https://www.brunogavranovic.com/papers.html
;; «gersting» (to ".gersting")
;; (find-angg ".emacs" "quadro")
(code-xpdf "gersting" "~/books/__comp/gersting__fundamentos_matematicos_para_a_ciencia_da_computacao_3a_ed.pdf")
(code-pdftotext "gersting" "~/books/__comp/gersting__fundamentos_matematicos_para_a_ciencia_da_computacao_3a_ed.pdf")
;; (find-gerstingpage 13 "Sumário")
;; (find-gerstingpage (+ 20 1) "1 Lógica Formal")
;; (find-gerstingpage (+ 20 2) "1.1 Sentenças, Representação Simbólica e Tautologias")
;; (find-gerstingpage (+ 20 12) "1.2 Quantficadores, Predicados e Validade")
;; (find-gerstingpage (+ 20 20) "1.3 Lógica Proposicional")
;; (find-gerstingpage (+ 20 27) "1.4 Lógica de Predicados")
;; (find-gerstingpage (+ 20 33) "1.5 Programação Lógica e Prova de Correção")
;; (find-gerstingpage (+ 20 49) "2 Demonstrações, Recursão e Análise de Algoritmo")
;; (find-gerstingpage (+ 20 50) "2.1 Técnicas de Demonstração")
;; (find-gerstingpage (+ 20 56) "2.2 Indução")
;; (find-gerstingpage (+ 20 64) "exercícios de indução")
;; (find-gerstingpage (+ 20 56) "2.3 Recursão e relação de recorrência")
;; (find-gerstingpage (+ 20 83) "2.4 análise de algoritmos")
;; (find-gerstingpage (+ 20 513) "Indice alfabetico")
;; (find-gerstingtext "")
;; «graham» (to ".graham")
;; (find-books "__comp/__comp.el" "graham")
;; http://paulgraham.com/rootsoflisp.html
;; http://lib.store.yahoo.net/lib/paulgraham/jmc.ps
;; (find-fline "$S/http/lib.store.yahoo.net/lib/paulgraham/")
(code-xpdf "rootsoflisp" "$S/http/lib.store.yahoo.net/lib/paulgraham/jmc.pdf")
(code-pdf-text "rootsoflisp" "$S/http/lib.store.yahoo.net/lib/paulgraham/jmc.pdf")
;; (find-rootsoflisppage)
;; (find-rootsoflisptext)
;; http://paulgraham.com/articles.html
;; http://paulgraham.com/ds.html Do things that don't scale
;; http://paulgraham.com/artistsship.html The other half of "Artists ship" - every check has a cost
;; http://paulgraham.com/lies.html Lies we tell kids
;; http://paulgraham.com/goodart.html How art can be good
;; http://paulgraham.com/pypar.html The Python paradox
;; http://paulgraham.com/icad.html Revenge of the nerds
;; http://paulgraham.com/gh.html Great hackers
;; http://paulgraham.com/gba.html The word "Hacker"
;; http://paulgraham.com/hp.html Hackers and painters
;; http://paulgraham.com/iflisp.html If Lisp is so great
;; http://paulgraham.com/nerds.html Why nerds are unpopular
;; http://paulgraham.com/hundred.html The hundred-year language
;; http://paulgraham.com/rootsoflisp.html The roots of Lisp
;; «graham-common-lisp» (to ".graham-common-lisp")
;; (find-books "__comp/__comp.el" "graham-common-lisp")
(code-pdf-page "ansicl" "~/books/__comp/graham__ansi_common_lisp.pdf")
(code-pdf-text "ansicl" "~/books/__comp/graham__ansi_common_lisp.pdf" 17)
;; (find-ansiclpage)
;; (find-ansiclpage 12 "Contents")
;; (find-ansiclpage (+ 1 189) "Index")
;; (find-ansicltext "")
;; (find-ansiclpage (+ 17 1) "1. Introduction")
;; (find-ansiclpage (+ 17 1) "1.1. New Tools")
;; (find-ansiclpage (+ 17 3) "1.2. New Techniques")
;; (find-ansiclpage (+ 17 4) "1.3. A New Approach")
;; (find-ansiclpage (+ 17 7) "2. Welcome to Lisp")
;; (find-ansiclpage (+ 17 7) "2.1. Form")
;; (find-ansiclpage (+ 17 9) "2.2. Evaluation")
;; (find-ansiclpage (+ 17 10) "2.3. Data")
;; (find-ansiclpage (+ 17 12) "2.4. List Operations")
;; (find-ansiclpage (+ 17 13) "2.5. Truth")
;; (find-ansiclpage (+ 17 14) "2.6. Functions")
;; (find-ansiclpage (+ 17 16) "2.7. Recursion")
;; (find-ansiclpage (+ 17 17) "2.8. Reading Lisp")
;; (find-ansiclpage (+ 17 18) "2.9. Input and Output")
;; (find-ansiclpage (+ 17 19) "2.10. Variables")
;; (find-ansiclpage (+ 17 21) "2.11. Assignment")
;; (find-ansiclpage (+ 17 22) "2.12. Functional Programming")
;; (find-ansiclpage (+ 17 23) "2.13. Iteration")
;; (find-ansiclpage (+ 17 25) "2.14. Functions as Objects")
;; (find-ansiclpage (+ 17 27) "2.15. Types")
;; (find-ansiclpage (+ 17 27) "2.16. Looking Forward")
;; (find-ansiclpage (+ 17 31) "3. Lists")
;; (find-ansiclpage (+ 17 31) "3.1. Conses")
;; (find-ansiclpage (+ 17 34) "3.2. Equality")
;; (find-ansiclpage (+ 17 34) "3.3. Why Lisp Has No Pointers")
;; (find-ansiclpage (+ 17 36) "3.4. Building Lists")
;; (find-ansiclpage (+ 17 36) "3.5. Example: Compression")
;; (find-ansiclpage (+ 17 39) "3.6. Access")
;; (find-ansiclpage (+ 17 40) "3.7. Mapping Functions")
;; (find-ansiclpage (+ 17 40) "3.8. Trees")
;; (find-ansiclpage (+ 17 42) "3.9. Understanding Recursion")
;; (find-ansiclpage (+ 17 43) "3.10. Sets")
;; (find-ansiclpage (+ 17 45) "3.11. Sequences")
;; (find-ansiclpage (+ 17 47) "3.12. Stacks")
;; (find-ansiclpage (+ 17 49) "3.13. Dotted Lists")
;; (find-ansiclpage (+ 17 51) "3.14. Assoc-lists")
;; (find-ansiclpage (+ 17 51) "3.15. Example: Shortest Path")
;; (find-ansiclpage (+ 17 54) "3.16. Garbage")
;; (find-ansiclpage (+ 17 58) "Structures")
;; (find-ansiclpage (+ 17 58) "4.1. Arrays")
;; (find-ansiclpage (+ 17 60) "4.2. Example: Binary Search")
;; (find-ansiclpage (+ 17 61) "4.3. Strings and Characters")
;; (find-ansiclpage (+ 17 63) "4.4. Sequences")
;; (find-ansiclpage (+ 17 66) "4.5. Example: Parsing Dates")
;; (find-ansiclpage (+ 17 69) "4.6. Structures")
;; (find-ansiclpage (+ 17 71) "Trees")
;; (find-ansiclpage (+ 17 76) "4.8. Hash Tables")
;; (find-ansiclpage (+ 17 81) "5. Control")
;; (find-ansiclpage (+ 17 81) "5.1. Blocks")
;; (find-ansiclpage (+ 17 83) "5.2. Context")
;; (find-ansiclpage (+ 17 85) "5.3. Conditionals")
;; (find-ansiclpage (+ 17 87) "5.4. Iteration")
;; (find-ansiclpage (+ 17 89) "5.5. Multiple Values")
;; (find-ansiclpage (+ 17 91) "5.6. Aborts")
;; (find-ansiclpage (+ 17 92) "5.7. Example: Date Arithmetic")
;; (find-ansiclpage (+ 17 99) "6. Functions")
;; (find-ansiclpage (+ 17 99) "6.1. Global Functions")
;; (find-ansiclpage (+ 17 101) "6.2. Local Functions")
;; (find-ansiclpage (+ 17 102) "6.3. Parameter Lists")
;; (find-ansiclpage (+ 17 104) "6.4. Example: Utilities")
;; (find-ansiclpage (+ 17 107) "6.5. Closures")
;; (find-ansiclpage (+ 17 109) "Builders")
;; (find-ansiclpage (+ 17 112) "6.7. Dynamic Scope")
;; (find-ansiclpage (+ 17 113) "6.8. Compilation")
;; (find-ansiclpage (+ 17 114) "6.9. Using Recursion")
;; (find-ansiclpage (+ 17 119) "7. Input and Output")
;; (find-ansiclpage (+ 17 119) "7.1. Streams")
;; (find-ansiclpage (+ 17 121) "7.2. Input")
;; (find-ansiclpage (+ 17 123) "7.3. Output")
;; (find-ansiclpage (+ 17 125) "Substitution")
;; (find-ansiclpage (+ 17 130) "7.5. Macro Characters")
;; (find-ansiclpage (+ 17 133) "8. Symbols")
;; (find-ansiclpage (+ 17 133) "8.1. Symbol Names")
;; (find-ansiclpage (+ 17 134) "8.2. Property Lists")
;; (find-ansiclpage (+ 17 135) "8.3. Symbols Are Big")
;; (find-ansiclpage (+ 17 136) "8.4. Creating Symbols")
;; (find-ansiclpage (+ 17 136) "8.5. Multiple Packages")
;; (find-ansiclpage (+ 17 137) "8.6. Keywords")
;; (find-ansiclpage (+ 17 138) "8.7. Symbols and Variables")
;; (find-ansiclpage (+ 17 138) "8.8. Example: Random Text")
;; (find-ansiclpage (+ 17 143) "9. Numbers")
;; (find-ansiclpage (+ 17 143) "9.1. Types")
;; (find-ansiclpage (+ 17 144) "Extraction")
;; (find-ansiclpage (+ 17 146) "9.3. Comparison")
;; (find-ansiclpage (+ 17 147) "9.4. Arithmetic")
;; (find-ansiclpage (+ 17 148) "9.5. Exponentiation")
;; (find-ansiclpage (+ 17 149) "9.6. Trigonometric Functions")
;; (find-ansiclpage (+ 17 150) "9.7. Representation")
;; (find-ansiclpage (+ 17 151) "9.8. Example: Ray-Tracing")
;; (find-ansiclpage (+ 17 160) "10. Macros")
;; (find-ansiclpage (+ 17 160) "10.1. Eval")
;; (find-ansiclpage (+ 17 162) "10.2. Macros")
;; (find-ansiclpage (+ 17 163) "10.3. Backquote")
;; (find-ansiclpage (+ 17 164) "10.4. Example: Quicksort")
;; (find-ansiclpage (+ 17 165) "10.5. Macro Design")
;; (find-ansiclpage (+ 17 168) "10.6. Generalized Reference")
;; (find-ansiclpage (+ 17 169) "Utilities")
;; (find-ansiclpage (+ 17 173) "10.8. On Lisp")
;; (find-ansiclpage (+ 17 176) "11. CLOS")
;; (find-ansiclpage (+ 17 176) "Programming")
;; (find-ansiclpage (+ 17 179) "11.2. Classes and Instances")
;; (find-ansiclpage (+ 17 179) "11.3. Slot Properties")
;; (find-ansiclpage (+ 17 181) "11.4. Superclasses")
;; (find-ansiclpage (+ 17 182) "11.5. Precedence")
;; (find-ansiclpage (+ 17 184) "11.6. Generic Functions")
;; (find-ansiclpage (+ 17 187) "11.7. Auxiliary Methods")
;; (find-ansiclpage (+ 17 189) "11.8. Method Combination")
;; (find-ansiclpage (+ 17 190) "11.9. Encapsulation")
;; (find-ansiclpage (+ 17 192) "11.10. Two Models")
;; (find-ansiclpage (+ 17 195) "12. Structure")
;; (find-ansiclpage (+ 17 195) "12.1. Shared Structure")
;; (find-ansiclpage (+ 17 198) "12.2. Modification")
;; (find-ansiclpage (+ 17 200) "12.3. Example: Queues")
;; (find-ansiclpage (+ 17 201) "12.4. Destructive Functions")
;; (find-ansiclpage (+ 17 203) "Trees")
;; (find-ansiclpage (+ 17 204) "Lists")
;; (find-ansiclpage (+ 17 208) "12.7. Circular Structure")
;; (find-ansiclpage (+ 17 210) "12.8. Constant Structure")
;; (find-ansiclpage (+ 17 213) "13. Speed")
;; (find-ansiclpage (+ 17 213) "13.1. The Bottleneck Rule")
;; (find-ansiclpage (+ 17 214) "13.2. Compilation")
;; (find-ansiclpage (+ 17 217) "13.3. Type Declarations")
;; (find-ansiclpage (+ 17 222) "13.4. Garbage Avoidance")
;; (find-ansiclpage (+ 17 226) "13.5. Example: Pools")
;; (find-ansiclpage (+ 17 228) "13.6. Fast Operators")
;; (find-ansiclpage (+ 17 229) "13.7. Two-Phase Development")
;; (find-ansiclpage (+ 17 232) "14. Advanced Topics")
;; (find-ansiclpage (+ 17 232) "14.1. Type Specifiers")
;; (find-ansiclpage (+ 17 234) "14.2. Binary Streams")
;; (find-ansiclpage (+ 17 235) "14.3. Read-Macros")
;; (find-ansiclpage (+ 17 236) "14.4. Packages")
;; (find-ansiclpage (+ 17 239) "14.5. The Loop Facility")
;; (find-ansiclpage (+ 17 244) "14.6. Conditions")
;; (find-ansiclpage (+ 17 247) "15. Example: Inference")
;; (find-ansiclpage (+ 17 247) "15.1. The Aim")
;; (find-ansiclpage (+ 17 248) "15.2. Matching")
;; (find-ansiclpage (+ 17 251) "15.3. Answering Queries")
;; (find-ansiclpage (+ 17 255) "15.4. Analysis")
;; (find-ansiclpage (+ 17 257) "HTML")
;; (find-ansiclpage (+ 17 257) "16.1. HTML")
;; (find-ansiclpage (+ 17 259) "16.2. HTML Utilities")
;; (find-ansiclpage (+ 17 262) "16.3. An Iteration Utility")
;; (find-ansiclpage (+ 17 264) "16.4. Generating Pages")
;; (find-ansiclpage (+ 17 269) "17. Example: Objects")
;; (find-ansiclpage (+ 17 269) "17.1. Inheritance")
;; (find-ansiclpage (+ 17 271) "17.2. Multiple Inheritance")
;; (find-ansiclpage (+ 17 273) "17.3. Defining Objects")
;; (find-ansiclpage (+ 17 274) "17.4. Functional Syntax")
;; (find-ansiclpage (+ 17 275) "17.5. Defining Methods")
;; (find-ansiclpage (+ 17 277) "17.6. Instances")
;; (find-ansiclpage (+ 17 277) "17.7. New Implementation")
;; (find-ansiclpage (+ 17 284) "17.8. Analysis")
;; (find-ansiclpage (+ 17 287) "A. Debugging")
;; (find-ansiclpage (+ 17 295) "B. Lisp in Lisp")
;; (find-ansiclpage (+ 17 304) "Lisp")
;; (find-ansiclpage (+ 17 310) "D. Language Reference")
;; (find-ansiclpage (+ 17 401) "Notes")
;; (find-ansiclpage (+ 17 415) "Index")
;; «graham-on-lisp» (to ".graham-on-lisp")
;; (find-books "__comp/__comp.el" "graham-on-lisp")
(code-pdf-page "grahamonlisp" "~/books/__comp/graham__on_lisp_advanced_techniques_for_common_lisp.pdf")
(code-pdf-text "grahamonlisp" "~/books/__comp/graham__on_lisp_advanced_techniques_for_common_lisp.pdf" 1)
;; (find-grahamonlisppage)
;; (find-grahamonlisppage 8 "Contents")
;; (find-grahamonlisppage (+ 1 189) "Index")
;; (find-grahamonlisptext "")
;; «graham-roots-of-lisp» (to ".graham-roots-of-lisp")
;; http://angg.twu.net/2016-optativa/graham__the_roots_of_lisp.pdf
(code-pdf-page "rootoflisp" "$S/http/angg.twu.net/2016-optativa/graham__the_roots_of_lisp.pdf")
(code-pdf-text "rootoflisp" "$S/http/angg.twu.net/2016-optativa/graham__the_roots_of_lisp.pdf")
;; (find-rootoflisppage)
;; (find-rootoflisptext)
;; «harper» (to ".harper")
;; (find-books "__comp/__comp.el" "harper")
;; https://www.cs.cmu.edu/~rwh/pfpl/
;; https://www.cs.cmu.edu/~rwh/pfpl/2nded.pdf
(code-pdf-page "harper" "~/books/__comp/harper__practical_foundations_for_programming_languages.pdf")
(code-pdf-text "harper" "~/books/__comp/harper__practical_foundations_for_programming_languages.pdf" 20)
;; (find-harperpage)
;; (find-harpertext)
;; (find-harperpage 7 "Contents")
;; (find-harperpage (+ 20 3) "1 Abstract Syntax")
;; (find-harperpage (+ 20 3) "1.1 Abstract Syntax Trees")
;; (find-harperpage (+ 20 4) "The concept of a variable is central")
;; (find-harpertext (+ 20 4) "The concept of a variable is central")
;; (find-harperpage (+ 20 6) "1.2 Abstract Binding Trees")
;; (find-harperpage (+ 20 6) "Variables are given meaning by")
;; (find-harpertext (+ 20 6) "Variables are given meaning by")
;; (find-harperpage (+ 20 9) "One trouble spot for substitution")
;; (find-harpertext (+ 20 9) "One trouble spot for substitution")
;; (find-harperpage (+ 20 10) "1.3 Notes")
;; (find-harperpage (+ 20 12) "2 Inductive Definitions")
;; (find-harperpage (+ 20 12) "2.1 Judgments")
;; (find-harperpage (+ 20 12) "2.2 Inference Rules")
;; (find-harperpage (+ 20 14) "2.3 Derivations")
;; (find-harperpage (+ 20 15) "2.4 Rule Induction")
;; (find-harperpage (+ 20 17) "2.5 Iterated and Simultaneous Inductive Definitions")
;; (find-harperpage (+ 20 18) "2.6 Defining Functions by Rules")
;; (find-harperpage (+ 20 19) "2.7 Notes")
;; (find-harperpage (+ 20 21) "3 Hypothetical and General Judgments")
;; (find-harperpage (+ 20 21) "3.1 Hypothetical Judgments")
;; (find-harperpage (+ 20 24) "3.2 Hypothetical Inductive Definitions")
;; (find-harperpage (+ 20 26) "3.3 General Judgments")
;; (find-harperpage (+ 20 27) "3.4 Generic Inductive Definitions")
;; (find-harperpage (+ 20 28) "3.5 Notes")
;; (find-harperpage (+ 20 33) "4 Statics")
;; (find-harperpage (+ 20 33) "4.1 Syntax")
;; (find-harperpage (+ 20 34) "4.2 Type System")
;; (find-harperpage (+ 20 35) "4.3 Structural Properties")
;; (find-harperpage (+ 20 37) "4.4 Notes")
;; (find-harperpage (+ 20 39) "5 Dynamics")
;; (find-harperpage (+ 20 39) "5.1 Transition Systems")
;; (find-harperpage (+ 20 40) "5.2 Structural Dynamics")
;; (find-harperpage (+ 20 42) "5.3 Contextual Dynamics")
;; (find-harperpage (+ 20 44) "5.4 Equational Dynamics")
;; (find-harperpage (+ 20 46) "5.5 Notes")
;; (find-harperpage (+ 20 48) "6 Type Safety")
;; (find-harperpage (+ 20 48) "6.1 Preservation")
;; (find-harperpage (+ 20 49) "6.2 Progress")
;; (find-harperpage (+ 20 50) "6.3 Run-Time Errors")
;; (find-harperpage (+ 20 52) "6.4 Notes")
;; (find-harperpage (+ 20 53) "7 Evaluation Dynamics")
;; (find-harperpage (+ 20 53) "7.1 Evaluation Dynamics")
;; (find-harperpage (+ 20 54) "7.2 Relating Structural and Evaluation Dynamics")
;; (find-harperpage (+ 20 55) "7.3 Type Safety, Revisited")
;; (find-harperpage (+ 20 56) "7.4 Cost Dynamics")
;; (find-harperpage (+ 20 57) "7.5 Notes")
;; (find-harperpage (+ 20 61) "8 Function Definitions and Values")
;; (find-harperpage (+ 20 61) "8.1 First-Order Functions")
;; (find-harperpage (+ 20 62) "8.2 Higher-Order Functions")
;; (find-harperpage (+ 20 65) "8.3 Evaluation Dynamics and Definitional Equality")
;; (find-harperpage (+ 20 66) "8.4 Dynamic Scope")
;; (find-harperpage (+ 20 67) "8.5 Notes")
;; (find-harperpage (+ 20 69) "9 System T of Higher-Order Recursion")
;; (find-harperpage (+ 20 69) "9.1 Statics")
;; (find-harperpage (+ 20 70) "9.2 Dynamics")
;; (find-harperpage (+ 20 71) "9.3 Definability")
;; (find-harperpage (+ 20 73) "9.4 Undefinability")
;; (find-harperpage (+ 20 75) "9.5 Notes")
;; (find-harperpage (+ 20 79) "10 Product Types")
;; (find-harperpage (+ 20 79) "10.1 Nullary and Binary Products")
;; (find-harperpage (+ 20 81) "10.2 Finite Products")
;; (find-harperpage (+ 20 82) "10.3 Primitive Mutual Recursion")
;; (find-harperpage (+ 20 83) "10.4 Notes")
;; (find-harperpage (+ 20 85) "11 Sum Types")
;; (find-harperpage (+ 20 85) "11.1 Nullary and Binary Sums")
;; (find-harperpage (+ 20 86) "11.2 Finite Sums")
;; (find-harperpage (+ 20 88) "11.3 Applications of Sum Types")
;; (find-harperpage (+ 20 91) "11.4 Notes")
;; (find-harperpage (+ 20 95) "12 Constructive Logic")
;; (find-harperpage (+ 20 95) "12.1 Constructive Semantics")
;; (find-harperpage (+ 20 96) "12.2 Constructive Logic")
;; (find-harperpage (+ 20 100) "12.3 Proof Dynamics")
;; (find-harperpage (+ 20 101) "12.4 Propositions as Types")
;; (find-harperpage (+ 20 101) "12.5 Notes")
;; (find-harperpage (+ 20 104) "13 Classical Logic")
;; (find-harperpage (+ 20 105) "13.1 Classical Logic")
;; (find-harperpage (+ 20 109) "13.2 Deriving Elimination Forms")
;; (find-harperpage (+ 20 110) "13.3 Proof Dynamics")
;; (find-harperpage (+ 20 111) "13.4 Law of the Excluded Middle")
;; (find-harperpage (+ 20 113) "13.5 The Double-Negation Translation")
;; (find-harperpage (+ 20 114) "13.6 Notes")
;; (find-harperpage (+ 20 119) "14 Generic Programming")
;; (find-harperpage (+ 20 119) "14.1 Introduction")
;; (find-harperpage (+ 20 119) "14.2 Polynomial Type Operators")
;; (find-harperpage (+ 20 122) "14.3 Positive Type Operators")
;; (find-harperpage (+ 20 123) "14.4 Notes")
;; (find-harperpage (+ 20 125) "15 Inductive and Coinductive Types")
;; (find-harperpage (+ 20 125) "15.1 Motivating Examples")
;; (find-harperpage (+ 20 128) "15.2 Statics")
;; (find-harperpage (+ 20 130) "15.3 Dynamics")
;; (find-harperpage (+ 20 131) "15.4 Solving Type Equations")
;; (find-harperpage (+ 20 132) "15.5 Notes")
;; (find-harperpage (+ 20 137) "16 System F of Polymorphic Types")
;; (find-harperpage (+ 20 137) "16.1 Polymorphic Abstraction")
;; (find-harperpage (+ 20 140) "16.2 Polymorphic Definability")
;; (find-harperpage (+ 20 142) "16.3 Parametricity Overview")
;; (find-harperpage (+ 20 144) "16.4 Notes")
;; (find-harperpage (+ 20 146) "17 Abstract Types")
;; (find-harperpage (+ 20 146) "17.1 Existential Types")
;; (find-harperpage (+ 20 149) "17.2 Data Abstraction")
;; (find-harperpage (+ 20 150) "17.3 Definability of Existential Types")
;; (find-harperpage (+ 20 151) "17.4 Representation Independence")
;; (find-harperpage (+ 20 153) "17.5 Notes")
;; (find-harperpage (+ 20 154) "18 Higher Kinds")
;; (find-harperpage (+ 20 155) "18.1 Constructors and Kinds")
;; (find-harperpage (+ 20 156) "18.2 Constructor Equality")
;; (find-harperpage (+ 20 157) "18.3 Expressions and Types")
;; (find-harperpage (+ 20 158) "18.4 Notes")
;; (find-harperpage (+ 20 161) "19 System PCF of Recursive Functions")
;; (find-harperpage (+ 20 162) "19.1 Statics")
;; (find-harperpage (+ 20 163) "19.2 Dynamics")
;; (find-harperpage (+ 20 165) "19.3 Definability")
;; (find-harperpage (+ 20 167) "19.4 Finite and Infinite Data Structures")
;; (find-harperpage (+ 20 167) "19.5 Totality and Partiality")
;; (find-harperpage (+ 20 169) "19.6 Notes")
;; (find-harperpage (+ 20 171) "20 System FPC of Recursive Types")
;; (find-harperpage (+ 20 171) "20.1 Solving Type Equations")
;; (find-harperpage (+ 20 172) "20.2 Inductive and Coinductive Types")
;; (find-harperpage (+ 20 174) "20.3 Self-Reference")
;; (find-harperpage (+ 20 176) "20.4 The Origin of State")
;; (find-harperpage (+ 20 177) "20.5 Notes")
;; (find-harperpage (+ 20 181) "21 The Untyped -Calculus")
;; (find-harperpage (+ 20 181) "21.1 The -Calculus")
;; (find-harperpage (+ 20 182) "21.2 Definability")
;; (find-harperpage (+ 20 184) "21.3 Scott's Theorem")
;; (find-harperpage (+ 20 186) "21.4 Untyped Means Uni-Typed")
;; (find-harperpage (+ 20 187) "21.5 Notes")
;; (find-harperpage (+ 20 189) "22 Dynamic Typing")
;; (find-harperpage (+ 20 189) "22.1 Dynamically Typed PCF")
;; (find-harperpage (+ 20 192) "22.2 Variations and Extensions")
;; (find-harperpage (+ 20 194) "22.3 Critique of Dynamic Typing")
;; (find-harperpage (+ 20 195) "22.4 Notes")
;; (find-harperpage (+ 20 198) "23 Hybrid Typing")
;; (find-harperpage (+ 20 198) "23.1 A Hybrid Language")
;; (find-harperpage (+ 20 200) "23.2 Dynamic as Static Typing")
;; (find-harperpage (+ 20 201) "23.3 Optimization of Dynamic Typing")
;; (find-harperpage (+ 20 203) "23.4 Static versus Dynamic Typing")
;; (find-harperpage (+ 20 204) "23.5 Notes")
;; (find-harperpage (+ 20 207) "24 Structural Subtyping")
;; (find-harperpage (+ 20 207) "24.1 Subsumption")
;; (find-harperpage (+ 20 208) "24.2 Varieties of Subtyping")
;; (find-harperpage (+ 20 211) "24.3 Variance")
;; (find-harperpage (+ 20 215) "24.4 Dynamics and Safety")
;; (find-harperpage (+ 20 216) "24.5 Notes")
;; (find-harperpage (+ 20 219) "25 Behavioral Typing")
;; (find-harperpage (+ 20 220) "25.1 Statics")
;; (find-harperpage (+ 20 226) "25.2 Boolean Blindness")
;; (find-harperpage (+ 20 228) "25.3 Refinement Safety")
;; (find-harperpage (+ 20 229) "25.4 Notes")
;; (find-harperpage (+ 20 235) "26 Classes and Methods")
;; (find-harperpage (+ 20 235) "26.1 The Dispatch Matrix")
;; (find-harperpage (+ 20 238) "26.2 Class-Based Organization")
;; (find-harperpage (+ 20 239) "26.3 Method-Based Organization")
;; (find-harperpage (+ 20 240) "26.4 Self-Reference")
;; (find-harperpage (+ 20 242) "26.5 Notes")
;; (find-harperpage (+ 20 245) "27 Inheritance")
;; (find-harperpage (+ 20 245) "27.1 Class and Method Extension")
;; (find-harperpage (+ 20 246) "27.2 Class-Based Inheritance")
;; (find-harperpage (+ 20 248) "27.3 Method-Based Inheritance")
;; (find-harperpage (+ 20 249) "27.4 Notes")
;; (find-harperpage (+ 20 253) "28 Control Stacks")
;; (find-harperpage (+ 20 253) "28.1 Machine Definition")
;; (find-harperpage (+ 20 255) "28.2 Safety")
;; (find-harperpage (+ 20 256) "28.3 Correctness of the K Machine")
;; (find-harperpage (+ 20 259) "28.4 Notes")
;; (find-harperpage (+ 20 260) "29 Exceptions")
;; (find-harperpage (+ 20 260) "29.1 Failures")
;; (find-harperpage (+ 20 262) "29.2 Exceptions")
;; (find-harperpage (+ 20 263) "29.3 Exception Values")
;; (find-harperpage (+ 20 264) "29.4 Notes")
;; (find-harperpage (+ 20 266) "30 Continuations")
;; (find-harperpage (+ 20 266) "30.1 Overview")
;; (find-harperpage (+ 20 268) "30.2 Continuation Dynamics")
;; (find-harperpage (+ 20 269) "30.3 Coroutines from Continuations")
;; (find-harperpage (+ 20 272) "30.4 Notes")
;; (find-harperpage (+ 20 277) "31 Symbols")
;; (find-harperpage (+ 20 277) "31.1 Symbol Declaration")
;; (find-harperpage (+ 20 280) "31.2 Symbol References")
;; (find-harperpage (+ 20 282) "31.3 Notes")
;; (find-harperpage (+ 20 284) "32 Fluid Binding")
;; (find-harperpage (+ 20 284) "32.1 Statics")
;; (find-harperpage (+ 20 285) "32.2 Dynamics")
;; (find-harperpage (+ 20 286) "32.3 Type Safety")
;; (find-harperpage (+ 20 287) "32.4 Some Subtleties")
;; (find-harperpage (+ 20 288) "32.5 Fluid References")
;; (find-harperpage (+ 20 289) "32.6 Notes")
;; (find-harperpage (+ 20 291) "33 Dynamic Classification")
;; (find-harperpage (+ 20 291) "33.1 Dynamic Classes")
;; (find-harperpage (+ 20 293) "33.2 Class References")
;; (find-harperpage (+ 20 294) "33.3 Definability of Dynamic Classes")
;; (find-harperpage (+ 20 295) "33.4 Applications of Dynamic Classification")
;; (find-harperpage (+ 20 296) "33.5 Notes")
;; (find-harperpage (+ 20 301) "34 Modernized Algol")
;; (find-harperpage (+ 20 301) "34.1 Basic Commands")
;; (find-harperpage (+ 20 306) "34.2 Some Programming Idioms")
;; (find-harperpage (+ 20 307) "34.3 Typed Commands and Typed Assignables")
;; (find-harperpage (+ 20 310) "34.4 Notes")
;; (find-harperpage (+ 20 313) "35 Assignable References")
;; (find-harperpage (+ 20 313) "35.1 Capabilities")
;; (find-harperpage (+ 20 314) "35.2 Scoped Assignables")
;; (find-harperpage (+ 20 316) "35.3 Free Assignables")
;; (find-harperpage (+ 20 318) "35.4 Safety")
;; (find-harperpage (+ 20 320) "35.5 Benign Effects")
;; (find-harperpage (+ 20 321) "35.6 Notes")
;; (find-harperpage (+ 20 323) "36 Lazy Evaluation")
;; (find-harperpage (+ 20 323) "36.1 PCF By-Need")
;; (find-harperpage (+ 20 326) "36.2 Safety of PCF By-Need")
;; (find-harperpage (+ 20 328) "36.3 FPC By-Need")
;; (find-harperpage (+ 20 329) "36.4 Suspension Types")
;; (find-harperpage (+ 20 331) "36.5 Notes")
;; (find-harperpage (+ 20 335) "37 Nested Parallelism")
;; (find-harperpage (+ 20 335) "37.1 Binary Fork-Join")
;; (find-harperpage (+ 20 338) "37.2 Cost Dynamics")
;; (find-harperpage (+ 20 341) "37.3 Multiple Fork-Join")
;; (find-harperpage (+ 20 342) "37.4 Bounded Implementations")
;; (find-harperpage (+ 20 346) "37.5 Scheduling")
;; (find-harperpage (+ 20 348) "37.6 Notes")
;; (find-harperpage (+ 20 350) "38 Futures and Speculations")
;; (find-harperpage (+ 20 350) "38.1 Futures")
;; (find-harperpage (+ 20 351) "38.2 Speculations")
;; (find-harperpage (+ 20 352) "38.3 Parallel Dynamics")
;; (find-harperpage (+ 20 354) "38.4 Pipelining with Futures")
;; (find-harperpage (+ 20 356) "38.5 Notes")
;; (find-harperpage (+ 20 359) "39 Process Calculus")
;; (find-harperpage (+ 20 359) "39.1 Actions and Events")
;; (find-harperpage (+ 20 361) "39.2 Interaction")
;; (find-harperpage (+ 20 363) "39.3 Replication")
;; (find-harperpage (+ 20 364) "39.4 Allocating Channels")
;; (find-harperpage (+ 20 366) "39.5 Communication")
;; (find-harperpage (+ 20 369) "39.6 Channel Passing")
;; (find-harperpage (+ 20 371) "39.7 Universality")
;; (find-harperpage (+ 20 372) "39.8 Notes")
;; (find-harperpage (+ 20 375) "40 Concurrent Algol")
;; (find-harperpage (+ 20 375) "40.1 Concurrent Algol")
;; (find-harperpage (+ 20 378) "40.2 Broadcast Communication")
;; (find-harperpage (+ 20 380) "40.3 Selective Communication")
;; (find-harperpage (+ 20 382) "40.4 Free Assignables as Processes")
;; (find-harperpage (+ 20 383) "40.5 Notes")
;; (find-harperpage (+ 20 385) "41 Distributed Algol")
;; (find-harperpage (+ 20 385) "41.1 Statics")
;; (find-harperpage (+ 20 388) "41.2 Dynamics")
;; (find-harperpage (+ 20 390) "41.3 Safety")
;; (find-harperpage (+ 20 391) "41.4 Notes")
;; (find-harperpage (+ 20 395) "42 Modularity and Linking")
;; (find-harperpage (+ 20 395) "42.1 Simple Units and Linking")
;; (find-harperpage (+ 20 396) "42.2 Initialization and Effects")
;; (find-harperpage (+ 20 398) "42.3 Notes")
;; (find-harperpage (+ 20 399) "43 Singleton Kinds and Subkinding")
;; (find-harperpage (+ 20 399) "43.1 Overview")
;; (find-harperpage (+ 20 400) "43.2 Singletons")
;; (find-harperpage (+ 20 402) "43.3 Dependent Kinds")
;; (find-harperpage (+ 20 405) "43.4 Higher Singletons")
;; (find-harperpage (+ 20 407) "43.5 Notes")
;; (find-harperpage (+ 20 409) "44 Type Abstractions and Type Classes")
;; (find-harperpage (+ 20 410) "44.1 Type Abstraction")
;; (find-harperpage (+ 20 412) "44.2 Type Classes")
;; (find-harperpage (+ 20 414) "44.3 A Module Language")
;; (find-harperpage (+ 20 418) "44.4 First- and Second-Class")
;; (find-harperpage (+ 20 419) "44.5 Notes")
;; (find-harperpage (+ 20 422) "45 Hierarchy and Parameterization")
;; (find-harperpage (+ 20 422) "45.1 Hierarchy")
;; (find-harperpage (+ 20 425) "45.2 Abstraction")
;; (find-harperpage (+ 20 427) "45.3 Hierarchy and Abstraction")
;; (find-harperpage (+ 20 429) "45.4 Applicative Functors")
;; (find-harperpage (+ 20 431) "45.5 Notes")
;; (find-harperpage (+ 20 435) "46 Equality for System T")
;; (find-harperpage (+ 20 435) "46.1 Observational Equivalence")
;; (find-harperpage (+ 20 439) "46.2 Logical Equivalence")
;; (find-harperpage (+ 20 440) "46.3 Logical and Observational Equivalence Coincide")
;; (find-harperpage (+ 20 443) "46.4 Some Laws of Equality")
;; (find-harperpage (+ 20 444) "46.5 Notes")
;; (find-harperpage (+ 20 445) "47 Equality for System PCF")
;; (find-harperpage (+ 20 445) "47.1 Observational Equivalence")
;; (find-harperpage (+ 20 446) "47.2 Logical Equivalence")
;; (find-harperpage (+ 20 446) "47.3 Logical and Observational Equivalence Coincide")
;; (find-harperpage (+ 20 449) "47.4 Compactness")
;; (find-harperpage (+ 20 452) "47.5 Lazy Natural Numbers")
;; (find-harperpage (+ 20 453) "47.6 Notes")
;; (find-harperpage (+ 20 454) "48 Parametricity")
;; (find-harperpage (+ 20 454) "48.1 Overview")
;; (find-harperpage (+ 20 455) "48.2 Observational Equivalence")
;; (find-harperpage (+ 20 456) "48.3 Logical Equivalence")
;; (find-harperpage (+ 20 461) "48.4 Parametricity Properties")
;; (find-harperpage (+ 20 464) "48.5 Representation Independence, Revisited")
;; (find-harperpage (+ 20 465) "48.6 Notes")
;; (find-harperpage (+ 20 467) "49 Process Equivalence")
;; (find-harperpage (+ 20 467) "49.1 Process Calculus")
;; (find-harperpage (+ 20 469) "49.2 Strong Equivalence")
;; (find-harperpage (+ 20 472) "49.3 Weak Equivalence")
;; (find-harperpage (+ 20 473) "49.4 Notes")
;; (find-harperpage (+ 20 477) "A Background on Finite Sets")
;; (find-harperpage (+ 20 479) "Bibliography")
;; (find-harperpage (+ 20 487) "Index")
;; (find-harperpage (+ 20 4) "Index")
;; (find-harpertext "")
;; «hopcroft» (to ".hopcroft")
(code-djvu "hopcroftmu" "~/books/__comp/hopcroft_motwani_ullman__introduction_to_automata_and_algorithms.djvu")
;; (find-hopcroftmupage 9 "Contents")
;; (find-hopcroftmupage (+ 16 1) "1. Automata: The Methods and the Madness")
;; (find-hopcroftmupage (+ 16 2) "1.1. Why study automata theory?")
;; (find-hopcroftmupage (+ 16 2) "1.1.1. Introduction to Finite Automata")
;; (find-hopcroftmupage (+ 16 4) "1.1.2. Structural Representations")
;; (find-hopcroftmupage (+ 16 5) "1.1.3. Automata and Complexity")
;; (find-hopcroftmupage (+ 16 5) "1.2. Introduction to Formal Proof")
;; (find-hopcroftmupage (+ 16 6) "1.2.1. Deductive Proofs")
;; (find-hopcroftmupage (+ 16 8) "1.2.2. Reduction to Definitions")
;; (find-hopcroftmupage (+ 16 10) "1.2.3. Other Theorem Forms")
;; (find-hopcroftmupage (+ 16 12) "How Formal Do Proofs Have to Be?")
;; (find-hopcroftmupage (+ 16 13) "1.2.4. Theorems That Appear Not to Be If-Then Statements")
;; (find-hopcroftmupage (+ 16 13) "1.3. Additional Forms of Proof")
;; (find-hopcroftmupage (+ 16 14) "1.3.1. Proving Equivalences About Sets")
;; (find-hopcroftmupage (+ 16 14) "1.3.2. The Contrapositive")
;; (find-hopcroftmupage (+ 16 16) "1.3.3. Proof by Contradiction")
;; (find-hopcroftmupage (+ 16 17) "1.3.4. Counterexamples")
;; (find-hopcroftmupage (+ 16 19) "1.4. Inductive Proofs")
;; (find-hopcroftmupage (+ 16 19) "1.4.1. Inductions on Integers")
;; (find-hopcroftmupage (+ 16 22) "1.4.2. More General Forms of Integer Inductions")
;; (find-hopcroftmupage (+ 16 23) "1.4.3. Structural Inductions")
;; (find-hopcroftmupage (+ 16 26) "1.4.4. Mutual Inductions")
;; (find-hopcroftmupage (+ 16 28) "1.5. The Central Concepts of Automata Theory")
;; (find-hopcroftmupage (+ 16 28) "1.5.1. Alphabets")
;; (find-hopcroftmupage (+ 16 29) "1.5.2. Strings")
;; (find-hopcroftmupage (+ 16 30) "1.5.3. Languages")
;; (find-hopcroftmupage (+ 16 31) "1.5.4. Problems")
;; (find-hopcroftmupage (+ 16 34) "1.6. Summary of Chapter 1")
;; (find-hopcroftmupage (+ 16 35) "1.7. References for Chapter 1")
;; (find-hopcroftmupage (+ 16 171) "5.1.2. Definition of Context-Free Grammars")
;; (find-hopcroftmupage (+ 16 181) "5.2. Parse Trees")
;; (find-hopcroftmupage (+ 16 194) "5.3.2. The YACC Parser-Generator")
;; (find-hopcroftmupage (+ 16 195) "5.3.2." "An example of a grammar in the YACC notation")
;; (find-hopcroftmupage (+ 16 205) "5.4.1. Ambiguous Grammars")
;; (find-hopcroftmupage (+ 16 368) "9.1. A Language That Is Not Recursively Enumerable")
;; (find-hopcroftmupage (+ 16 513) "Index")
;; «icon-book» (to ".icon-book")
;; (find-books "__comp/__comp.el" "icon-book")
;; https://www2.cs.arizona.edu/icon/ftp/doc/lb1up.pdf
(code-pdf-page "iconbook" "$S/https/www2.cs.arizona.edu/icon/ftp/doc/lb1up.pdf")
(code-pdf-text "iconbook" "$S/https/www2.cs.arizona.edu/icon/ftp/doc/lb1up.pdf" 22)
;; (find-iconbookpage)
;; (find-iconbooktext)
;; (find-iconbookpage 5 "Contents")
;; (find-iconbooktext 5 "Contents")
;; (find-iconbookpage (+ 2 11) "FOREWORD")
;; (find-iconbookpage (+ 2 15) "INTRODUCTION")
;; (find-iconbookpage (+ 2 19) "ACKNOWLEDGMENTS")
;; (find-iconbookpage (+ 22 1) "1 GETTING STARTED")
;; (find-iconbookpage (+ 22 1) "Program Structure")
;; (find-iconbookpage (+ 22 4) "Success and Failure")
;; (find-iconbookpage (+ 22 6) "Control Structures")
;; (find-iconbookpage (+ 22 7) "Procedures")
;; (find-iconbookpage (+ 22 9) "Expression Syntax")
;; (find-iconbookpage (+ 22 11) "Preprocessing")
;; (find-iconbookpage (+ 22 12) "Notes")
;; (find-iconbookpage (+ 22 17) "2 EXPRESSIONS")
;; (find-iconbookpage (+ 22 17) "Sequential Evaluation")
;; (find-iconbookpage (+ 22 18) "Goal-Directed Evaluation")
;; (find-iconbookpage (+ 22 20) "Iteration")
;; (find-iconbookpage (+ 22 20) "Integer Sequences")
;; (find-iconbookpage (+ 22 21) "Alternation")
;; (find-iconbookpage (+ 22 22) "Conjunction")
;; (find-iconbookpage (+ 22 23) "Loops")
;; (find-iconbookpage (+ 22 25) "Selection Expressions")
;; (find-iconbookpage (+ 22 28) "Comparison Operations")
;; (find-iconbookpage (+ 22 28) "Assignment")
;; (find-iconbookpage (+ 22 30) "Values, Variables, and Results")
;; (find-iconbookpage (+ 22 30) "Argument Evaluation")
;; (find-iconbookpage (+ 22 31) "Procedure Returns")
;; (find-iconbookpage (+ 22 32) "Notes")
;; (find-iconbookpage (+ 22 37) "3 STRING SCANNING")
;; (find-iconbookpage (+ 22 37) "The Concept of Scanning")
;; (find-iconbookpage (+ 22 38) "String Positions")
;; (find-iconbookpage (+ 22 39) "String Analysis")
;; (find-iconbookpage (+ 22 40) "Csets")
;; (find-iconbookpage (+ 22 41) "String-Analysis Functions")
;; (find-iconbookpage (+ 22 43) "Scanning Environments")
;; (find-iconbookpage (+ 22 44) "Scanning Keywords")
;; (find-iconbookpage (+ 22 44) "Augmented String Scanning")
;; (find-iconbookpage (+ 22 45) "Notes")
;; (find-iconbookpage (+ 22 47) "4 CHARACTERS, CSETS, AND STRINGS")
;; (find-iconbookpage (+ 22 47) "Characters")
;; (find-iconbookpage (+ 22 48) "Strings")
;; (find-iconbookpage (+ 22 50) "Lexical Comparison")
;; (find-iconbookpage (+ 22 51) "String Construction")
;; (find-iconbookpage (+ 22 52) "String-Valued Functions")
;; (find-iconbookpage (+ 22 56) "Substrings")
;; (find-iconbookpage (+ 22 60) "Csets")
;; (find-iconbookpage (+ 22 61) "String Analysis")
;; (find-iconbookpage (+ 22 61) "Conversion between Csets and Strings")
;; (find-iconbookpage (+ 22 62) "Notes")
;; (find-iconbookpage (+ 22 63) "5 NUMERICAL COMPUTATION AND BIT OPERATIONS")
;; (find-iconbookpage (+ 22 63) "Numeric Literals")
;; (find-iconbookpage (+ 22 64) "Arithmetic")
;; (find-iconbookpage (+ 22 65) "Numerical Comparison")
;; (find-iconbookpage (+ 22 65) "Mathematical Computations")
;; (find-iconbookpage (+ 22 66) "Random Numbers")
;; (find-iconbookpage (+ 22 66) "Bit Operations")
;; (find-iconbookpage (+ 22 67) "Notes")
;; (find-iconbookpage (+ 22 71) "6 STRUCTURES")
;; (find-iconbookpage (+ 22 71) "Records")
;; (find-iconbookpage (+ 22 73) "The tree corresponding to expression")
;; (find-iconbooktext (+ 22 73) "The tree corresponding to expression")
;; (find-iconbookpage (+ 22 72) "Lists")
;; (find-iconbookpage (+ 22 79) "Sets")
;; (find-iconbookpage (+ 22 81) "Tables")
;; (find-iconbookpage (+ 22 83) "Properties of Structures")
;; (find-iconbookpage (+ 22 84) "Notes")
;; (find-iconbookpage (+ 22 87) "7 EXPRESSION EVALUATION")
;; (find-iconbookpage (+ 22 87) "Backtracking")
;; (find-iconbookpage (+ 22 90) "Bounded Expressions")
;; (find-iconbookpage (+ 22 92) "Mutual Evaluation")
;; (find-iconbookpage (+ 22 93) "Limiting Generation")
;; (find-iconbookpage (+ 22 94) "Repeated Alternation")
;; (find-iconbookpage (+ 22 95) "Notes")
;; (find-iconbookpage (+ 22 97) "8 PROCEDURES")
;; (find-iconbookpage (+ 22 97) "Procedure Declarations")
;; (find-iconbookpage (+ 22 99) "Scope")
;; (find-iconbookpage (+ 22 101) "Procedure Invocation")
;; (find-iconbookpage (+ 22 103) "Variables and Dereferencing")
;; (find-iconbookpage (+ 22 105) "Notes")
;; (find-iconbookpage (+ 22 109) "9 CO-EXPRESSIONS")
;; (find-iconbookpage (+ 22 109) "Co-Expression Operations")
;; (find-iconbookpage (+ 22 113) "Using Co-Expressions")
;; (find-iconbookpage (+ 22 115) "Programmer-Defined Control Structures")
;; (find-iconbookpage (+ 22 118) "Other Features of Co-Expressions")
;; (find-iconbookpage (+ 22 122) "Notes")
;; (find-iconbookpage (+ 22 123) "10 DATA TYPES")
;; (find-iconbookpage (+ 22 123) "Type Determination")
;; (find-iconbookpage (+ 22 124) "Type Conversion")
;; (find-iconbookpage (+ 22 127) "The Null Value")
;; (find-iconbookpage (+ 22 128) "Comparing Values")
;; (find-iconbookpage (+ 22 130) "Copying Values")
;; (find-iconbookpage (+ 22 131) "Notes")
;; (find-iconbookpage (+ 22 133) "11 INPUT AND OUTPUT")
;; (find-iconbookpage (+ 22 133) "Files")
;; (find-iconbookpage (+ 22 135) "Input")
;; (find-iconbookpage (+ 22 136) "Output")
;; (find-iconbookpage (+ 22 138) "Text Files and Binary Files")
;; (find-iconbookpage (+ 22 140) "Pipes")
;; (find-iconbookpage (+ 22 141) "Keyboard Functions")
;; (find-iconbookpage (+ 22 141) "Random-Access Input and Output")
;; (find-iconbookpage (+ 22 141) "Operations on Files")
;; (find-iconbookpage (+ 22 142) "Notes")
;; (find-iconbookpage (+ 22 143) "12 AN OVERVIEW OF GRAPHICS")
;; (find-iconbookpage (+ 22 143) "Window Operations and Attributes")
;; (find-iconbookpage (+ 22 145) "Drawing")
;; (find-iconbookpage (+ 22 149) "Text")
;; (find-iconbookpage (+ 22 151) "Color")
;; (find-iconbookpage (+ 22 153) "Images")
;; (find-iconbookpage (+ 22 155) "Events")
;; (find-iconbookpage (+ 22 157) "Dialogs")
;; (find-iconbookpage (+ 22 158) "Visual Interfaces")
;; (find-iconbookpage (+ 22 159) "Other Features")
;; (find-iconbookpage (+ 22 160) "Notes")
;; (find-iconbookpage (+ 22 161) "13 OTHER FEATURES")
;; (find-iconbookpage (+ 22 161) "Sorting Structures")
;; (find-iconbookpage (+ 22 163) "String Names")
;; (find-iconbookpage (+ 22 164) "String Invocation")
;; (find-iconbookpage (+ 22 166) "Dynamic Loading")
;; (find-iconbookpage (+ 22 166) "Storage Management")
;; (find-iconbookpage (+ 22 169) "Miscellaneous Facilities")
;; (find-iconbookpage (+ 22 171) "Notes")
;; (find-iconbookpage (+ 22 173) "14 RUNNING AN ICON PROGRAM")
;; (find-iconbookpage (+ 22 173) "Basics")
;; (find-iconbookpage (+ 22 174) "Input and Output Redirection")
;; (find-iconbookpage (+ 22 175) "Command-Line Arguments")
;; (find-iconbookpage (+ 22 175) "Environment Variables")
;; (find-iconbookpage (+ 22 176) "Notes")
;; (find-iconbookpage (+ 22 177) "15 LIBRARIES")
;; (find-iconbookpage (+ 22 177) "Using Procedure Libraries")
;; (find-iconbookpage (+ 22 178) "The Icon Program Library")
;; (find-iconbookpage (+ 22 184) "Creating New Library Modules")
;; (find-iconbookpage (+ 22 185) "Notes")
;; (find-iconbookpage (+ 22 187) "16 ERRORS AND DIAGNOSTIC FACILITIES")
;; (find-iconbookpage (+ 22 187) "Errors")
;; (find-iconbookpage (+ 22 189) "Error Conversion")
;; (find-iconbookpage (+ 22 190) "String Images")
;; (find-iconbookpage (+ 22 192) "Program Information")
;; (find-iconbookpage (+ 22 192) "Tracing")
;; (find-iconbookpage (+ 22 193) "The resulting trace output is")
;; (find-iconbooktext (+ 22 193) "The resulting trace output is")
;; (find-iconbookpage (+ 22 195) "The Values of Variables")
;; (find-iconbookpage (+ 22 197) "Variables and Names")
;; (find-iconbookpage (+ 22 198) "Notes")
;; (find-iconbookpage (+ 22 201) "17 PROGRAMMING WITH GENERATORS")
;; (find-iconbookpage (+ 22 201) "Nested Iteration")
;; (find-iconbookpage (+ 22 203) "Goal-Directed Evaluation and Searching")
;; (find-iconbookpage (+ 22 210) "Recursive Generators")
;; (find-iconbookpage (+ 22 211) "18 STRING SCANNING AND PATTERN MATCHING")
;; (find-iconbookpage (+ 22 211) "Arithmetic Expressions")
;; (find-iconbookpage (+ 22 216) "Pattern Matching")
;; (find-iconbookpage (+ 22 220) "Grammars and Languages")
;; (find-iconbookpage (+ 22 227) "19 USING STRUCTURES")
;; (find-iconbookpage (+ 22 227) "Trees")
;; (find-iconbookpage (+ 22 231) "Dags")
;; (find-iconbookpage (+ 22 231) "DAGS")
;; (find-iconbooktext (+ 22 231) "DAGS")
;; (find-iconbookpage (+ 22 233) "Graphs")
;; (find-iconbookpage (+ 22 235) "Two-Way Tables")
;; (find-iconbookpage (+ 22 237) "20 MAPPINGS AND LABELINGS")
;; (find-iconbookpage (+ 22 237) "Mapping Techniques")
;; (find-iconbookpage (+ 22 242) "Labelings")
;; (find-iconbookpage (+ 22 247) "A SYNTAX")
;; (find-iconbookpage (+ 22 248) "Programs")
;; (find-iconbookpage (+ 22 252) "Language Elements")
;; (find-iconbookpage (+ 22 255) "Program Layout")
;; (find-iconbookpage (+ 22 257) "Precedence and Associativity")
;; (find-iconbookpage (+ 22 261) "B CHARACTERS")
;; (find-iconbookpage (+ 22 261) "Glyphs")
;; (find-iconbookpage (+ 22 268) "ASCII Control Characters")
;; (find-iconbookpage (+ 22 269) "C PREPROCESSING")
;; (find-iconbookpage (+ 22 269) "Include Directives")
;; (find-iconbookpage (+ 22 270) "Line Directives")
;; (find-iconbookpage (+ 22 270) "Define Directives")
;; (find-iconbookpage (+ 22 271) "Undefine Directives")
;; (find-iconbookpage (+ 22 271) "Predefined Symbols")
;; (find-iconbookpage (+ 22 271) "Substitution")
;; (find-iconbookpage (+ 22 272) "Conditional Compilation")
;; (find-iconbookpage (+ 22 272) "Error Directives")
;; (find-iconbookpage (+ 22 273) "D LANGUAGE REFERENCE MANUAL")
;; (find-iconbookpage (+ 22 275) "Functions")
;; (find-iconbookpage (+ 22 295) "Prefix Operations")
;; (find-iconbookpage (+ 22 298) "Infix Operations")
;; (find-iconbookpage (+ 22 303) "Other Operations")
;; (find-iconbookpage (+ 22 306) "Keywords")
;; (find-iconbookpage (+ 22 311) "Control Structures")
;; (find-iconbookpage (+ 22 314) "Generators")
;; (find-iconbookpage (+ 22 315) "E COMMAND-LINE OPTIONS")
;; (find-iconbookpage (+ 22 317) "F ENVIRONMENT VARIABLES")
;; (find-iconbookpage (+ 22 319) "G ERROR MESSAGES")
;; (find-iconbookpage (+ 22 319) "Preprocessor Errors")
;; (find-iconbookpage (+ 22 320) "Syntax Errors")
;; (find-iconbookpage (+ 22 321) "Linking Error")
;; (find-iconbookpage (+ 22 321) "Run-Time Errors")
;; (find-iconbookpage (+ 22 323) "H PLATFORM-SPECIFIC DIFFERENCES")
;; (find-iconbookpage (+ 22 324) "Character Sets")
;; (find-iconbookpage (+ 22 325) "Language Features")
;; (find-iconbookpage (+ 22 326) "Other Issues")
;; (find-iconbookpage (+ 22 329) "I SAMPLE PROGRAMS")
;; (find-iconbookpage (+ 22 329) "Command-Line Options")
;; (find-iconbookpage (+ 22 331) "Structure Images")
;; (find-iconbookpage (+ 22 334) "Concordances")
;; (find-iconbookpage (+ 22 337) "Animal Game")
;; (find-iconbookpage (+ 22 341) "Randomly Generated Sentences")
;; (find-iconbookpage (+ 22 348) "N Queens")
;; (find-iconbookpage (+ 22 350) "N Queens Displayed Graphically")
;; (find-iconbookpage (+ 22 355) "J ICON RESOURCES")
;; (find-iconbookpage (+ 22 357) "GLOSSARY")
;; (find-iconbookpage (+ 22 369) "REFERENCES")
;; (find-iconbookpage (+ 22 373) "INDEX")
;; «ierusalimschy» (to ".ierusalimschy")
;; (find-books "__comp/__comp.el" "ierusalimschy")
;; (find-angg ".emacs.papers" "lua")
(code-pdf-page "pil2" "~/books/__comp/ierusalimschy__programming_in_lua_2nd_ed.pdf")
(code-pdf-text "pil2" "~/books/__comp/ierusalimschy__programming_in_lua_2nd_ed.pdf" 19)
(code-pdf-page "pil3" "~/books/__comp/ierusalimschy__programming_in_lua_3rd_ed.pdf")
(code-pdf-text "pil3" "~/books/__comp/ierusalimschy__programming_in_lua_3rd_ed.pdf" 19)
;; (find-pil3page)
;; (find-pil3page 8 "Contents")
;; (find-pil3text 8 "Contents")
;; (find-pil3page (+ 19 1) "I. The Language")
;; (find-pil3page (+ 19 339) "Index")
;; (find-pil3page (+ 19 1) "I The Language")
;; (find-pil3page (+ 19 3) "1 Getting Started")
;; (find-pil3page (+ 19 4) "1.1 Chunks")
;; (find-pil3page (+ 19 5) "1.2 Some Lexical Conventions")
;; (find-pil3page (+ 19 6) "1.3 Global Variables")
;; (find-pil3page (+ 19 6) "1.4 The Stand-Alone Interpreter")
;; (find-pil3page (+ 19 8) "Exercises")
;; (find-pil3page (+ 19 9) "2 Types and Values")
;; (find-pil3page (+ 19 10) "2.1 Nil")
;; (find-pil3page (+ 19 10) "2.2 Booleans")
;; (find-pil3page (+ 19 10) "2.3 Numbers")
;; (find-pil3page (+ 19 11) "2.4 Strings")
;; (find-pil3page (+ 19 15) "2.5 Tables")
;; (find-pil3page (+ 19 18) "2.6 Functions")
;; (find-pil3page (+ 19 18) "2.7 Userdata and Threads")
;; (find-pil3page (+ 19 18) "Exercises")
;; (find-pil3page (+ 19 21) "3 Expressions")
;; (find-pil3page (+ 19 21) "3.1 Arithmetic Operators")
;; (find-pil3page (+ 19 22) "3.2 Relational Operators")
;; (find-pil3page (+ 19 23) "3.3 Logical Operators")
;; (find-pil3page (+ 19 23) "3.4 Concatenation")
;; (find-pil3page (+ 19 24) "3.5 The Length Operator")
;; (find-pil3page (+ 19 25) "3.6 Precedence")
;; (find-pil3page (+ 19 26) "3.7 Table Constructors")
;; (find-pil3page (+ 19 28) "Exercises")
;; (find-pil3page (+ 19 29) "4 Statements")
;; (find-pil3page (+ 19 29) "4.1 Assignment")
;; (find-pil3page (+ 19 30) "4.2 Local Variables and Blocks")
;; (find-pil3page (+ 19 32) "4.3 Control Structures")
;; (find-pil3page (+ 19 36) "4.4 break, return, and goto")
;; (find-pil3page (+ 19 38) "Exercises")
;; (find-pil3page (+ 19 41) "5 Functions")
;; (find-pil3page (+ 19 42) "5.1 Multiple Results")
;; (find-pil3page (+ 19 46) "5.2 Variadic Functions")
;; (find-pil3page (+ 19 48) "5.3 Named Arguments")
;; (find-pil3page (+ 19 49) "Exercises")
;; (find-pil3page (+ 19 51) "6 More about Functions")
;; (find-pil3page (+ 19 53) "6.1 Closures")
;; (find-pil3page (+ 19 56) "6.2 Non-Global Functions")
;; (find-pil3page (+ 19 58) "6.3 Proper Tail Calls")
;; (find-pil3page (+ 19 59) "Exercises")
;; (find-pil3page (+ 19 61) "7 Iterators and the Generic for")
;; (find-pil3page (+ 19 61) "7.1 Iterators and Closures")
;; (find-pil3page (+ 19 63) "7.2 The Semantics of the Generic for")
;; (find-pil3page (+ 19 64) "7.3 Stateless Iterators")
;; (find-pil3page (+ 19 66) "7.4 Iterators with Complex State")
;; (find-pil3page (+ 19 67) "7.5 True Iterators")
;; (find-pil3page (+ 19 68) "Exercises")
;; (find-pil3page (+ 19 71) "8 Compilation, Execution, and Errors")
;; (find-pil3page (+ 19 71) "8.1 Compilation")
;; (find-pil3page (+ 19 75) "8.2 Precompiled Code")
;; (find-pil3page (+ 19 76) "8.3 C Code")
;; (find-pil3page (+ 19 77) "8.4 Errors")
;; (find-pil3page (+ 19 79) "8.5 Error Handling and Exceptions")
;; (find-pil3page (+ 19 79) "8.6 Error Messages and Tracebacks")
;; (find-pil3page (+ 19 81) "Exercises")
;; (find-pil3page (+ 19 83) "9 Coroutines")
;; (find-pil3page (+ 19 83) "9.1 Coroutine Basics")
;; (find-pil3page (+ 19 86) "9.2 Pipes and Filters")
;; (find-pil3page (+ 19 89) "9.3 Coroutines as Iterators")
;; (find-pil3page (+ 19 91) "9.4 Non-Preemptive Multithreading")
;; (find-pil3page (+ 19 95) "Exercises")
;; (find-pil3page (+ 19 97) "10 Complete Examples")
;; (find-pil3page (+ 19 97) "10.1 The Eight-Queen Puzzle")
;; (find-pil3page (+ 19 99) "10.2 Most Frequent Words")
;; (find-pil3page (+ 19 101) "10.3 Markov Chain Algorithm")
;; (find-pil3page (+ 19 102) "Exercises")
;; (find-pil3page (+ 19 105) "II Tables and Objects")
;; (find-pil3page (+ 19 107) "11 Data Structures")
;; (find-pil3page (+ 19 107) "11.1 Arrays")
;; (find-pil3page (+ 19 108) "11.2 Matrices and Multi-Dimensional Arrays")
;; (find-pil3page (+ 19 110) "11.3 Linked Lists")
;; (find-pil3page (+ 19 110) "11.4 Queues and Double Queues")
;; (find-pil3page (+ 19 111) "11.5 Sets and Bags")
;; (find-pil3page (+ 19 113) "11.6 String Buffers")
;; (find-pil3page (+ 19 114) "11.7 Graphs")
;; (find-pil3page (+ 19 116) "Exercises")
;; (find-pil3page (+ 19 117) "12 Data Files and Persistence")
;; (find-pil3page (+ 19 117) "12.1 Data Files")
;; (find-pil3page (+ 19 119) "12.2 Serialization")
;; (find-pil3page (+ 19 125) "Exercises")
;; (find-pil3page (+ 19 127) "13 Metatables and Metamethods")
;; (find-pil3page (+ 19 128) "13.1 Arithmetic Metamethods")
;; (find-pil3page (+ 19 131) "13.2 Relational Metamethods")
;; (find-pil3page (+ 19 132) "13.3 Library-Defined Metamethods")
;; (find-pil3page (+ 19 133) "13.4 Table-Access Metamethods")
;; (find-pil3page (+ 19 138) "Exercises")
;; (find-pil3page (+ 19 139) "14 The Environment")
;; (find-pil3page (+ 19 139) "14.1 Global Variables with Dynamic Names")
;; (find-pil3page (+ 19 141) "14.2 Global-Variable Declarations")
;; (find-pil3page (+ 19 142) "14.3 Non-Global Environments")
;; (find-pil3page (+ 19 144) "14.4 Using")
;; (find-pil3page (+ 19 147) "14.5 and")
;; (find-pil3page (+ 19 148) "Exercises")
;; (find-pil3page (+ 19 151) "15 Modules and Packages")
;; (find-pil3page (+ 19 153) "15.1 The require Function")
;; (find-pil3page (+ 19 156) "15.2 The Basic Approach for Writing Modules in Lua")
;; (find-pil3page (+ 19 158) "15.3 Using Environments")
;; (find-pil3page (+ 19 159) "15.4 Submodules and Packages")
;; (find-pil3page (+ 19 161) "Exercises")
;; (find-pil3page (+ 19 163) "16 Object-Oriented Programming")
;; (find-pil3page (+ 19 165) "16.1 Classes")
;; (find-pil3page (+ 19 166) "16.2 Inheritance")
;; (find-pil3page (+ 19 168) "16.3 Multiple Inheritance")
;; (find-pil3page (+ 19 170) "16.4 Privacy")
;; (find-pil3page (+ 19 172) "16.5 The Single-Method Approach")
;; (find-pil3page (+ 19 173) "Exercises")
;; (find-pil3page (+ 19 175) "17 Weak Tables and Finalizers")
;; (find-pil3page (+ 19 175) "17.1 Weak Tables")
;; (find-pil3page (+ 19 177) "17.2 Memoize Functions")
;; (find-pil3page (+ 19 179) "17.3 Object Attributes")
;; (find-pil3page (+ 19 179) "17.4 Revisiting Tables with Default Values")
;; (find-pil3page (+ 19 180) "17.5 Ephemeron Tables")
;; (find-pil3page (+ 19 181) "17.6 Finalizers")
;; (find-pil3page (+ 19 185) "Exercises")
;; (find-pil3page (+ 19 187) "III The Standard Libraries")
;; (find-pil3page (+ 19 189) "18 The Mathematical Library")
;; (find-pil3page (+ 19 190) "Exercises")
;; (find-pil3page (+ 19 191) "19 The Bitwise Library")
;; (find-pil3page (+ 19 194) "Exercises")
;; (find-pil3page (+ 19 195) "20 The Table Library")
;; (find-pil3page (+ 19 195) "20.1 Insert and Remove")
;; (find-pil3page (+ 19 196) "20.2 Sort")
;; (find-pil3page (+ 19 197) "20.3 Concatenation")
;; (find-pil3page (+ 19 198) "Exercises")
;; (find-pil3page (+ 19 199) "21 The String Library")
;; (find-pil3page (+ 19 199) "21.1 Basic String Functions")
;; (find-pil3page (+ 19 201) "21.2 Pattern-Matching Functions")
;; (find-pil3page (+ 19 204) "21.3 Patterns")
;; (find-pil3page (+ 19 208) "21.4 Captures")
;; (find-pil3page (+ 19 209) "21.5 Replacements")
;; (find-pil3page (+ 19 213) "21.6 Tricks of the Trade")
;; (find-pil3page (+ 19 216) "21.7 Unicode")
;; (find-pil3page (+ 19 218) "Exercises")
;; (find-pil3page (+ 19 221) "22 The I/O Library")
;; (find-pil3page (+ 19 221) "22.1 The Simple I/O Model")
;; (find-pil3page (+ 19 224) "22.2 The Complete I/O Model")
;; (find-pil3page (+ 19 228) "22.3 Other Operations on Files")
;; (find-pil3page (+ 19 229) "Exercises")
;; (find-pil3page (+ 19 231) "23 The Operating System Library")
;; (find-pil3page (+ 19 231) "23.1 Date and Time")
;; (find-pil3page (+ 19 233) "23.2 Other System Calls")
;; (find-pil3page (+ 19 235) "Exercises")
;; (find-pil3page (+ 19 237) "24 The Debug Library")
;; (find-pil3page (+ 19 237) "24.1 Introspective Facilities")
;; (find-pil3page (+ 19 242) "24.2 Hooks")
;; (find-pil3page (+ 19 243) "24.3 Profiles")
;; (find-pil3page (+ 19 245) "Exercises")
;; (find-pil3page (+ 19 247) "IV The C API")
;; (find-pil3page (+ 19 249) "25 An Overview of the C API")
;; (find-pil3page (+ 19 250) "25.1 A First Example")
;; (find-pil3page (+ 19 253) "25.2 The Stack")
;; (find-pil3page (+ 19 258) "25.3 Error Handling with the C API")
;; (find-pil3page (+ 19 260) "Exercises")
;; (find-pil3page (+ 19 261) "26 Extending Your Application")
;; (find-pil3page (+ 19 261) "26.1 The Basics")
;; (find-pil3page (+ 19 263) "26.2 Table Manipulation")
;; (find-pil3page (+ 19 267) "26.3 Calling Lua Functions")
;; (find-pil3page (+ 19 269) "26.4 A Generic Call Function")
;; (find-pil3page (+ 19 270) "Exercises")
;; (find-pil3page (+ 19 273) "27 Calling C from Lua")
;; (find-pil3page (+ 19 273) "27.1 C Functions")
;; (find-pil3page (+ 19 275) "27.2 Continuations")
;; (find-pil3page (+ 19 278) "27.3 C Modules")
;; (find-pil3page (+ 19 280) "Exercises")
;; (find-pil3page (+ 19 281) "28 Techniques for Writing C Functions")
;; (find-pil3page (+ 19 281) "28.1 Array Manipulation")
;; (find-pil3page (+ 19 283) "28.2 String Manipulation")
;; (find-pil3page (+ 19 286) "28.3 Storing State in C Functions")
;; (find-pil3page (+ 19 292) "Exercises")
;; (find-pil3page (+ 19 293) "29 User-Defined Types in C")
;; (find-pil3page (+ 19 294) "29.1 Userdata")
;; (find-pil3page (+ 19 296) "29.2 Metatables")
;; (find-pil3page (+ 19 299) "29.3 Object-Oriented Access")
;; (find-pil3page (+ 19 300) "29.4 Array Access")
;; (find-pil3page (+ 19 301) "29.5 Light Userdata")
;; (find-pil3page (+ 19 302) "Exercises")
;; (find-pil3page (+ 19 305) "30 Managing Resources")
;; (find-pil3page (+ 19 305) "30.1 A Directory Iterator")
;; (find-pil3page (+ 19 307) "30.2 An XML Parser")
;; (find-pil3page (+ 19 316) "Exercises")
;; (find-pil3page (+ 19 319) "31 Threads and States")
;; (find-pil3page (+ 19 319) "31.1 Multiple Threads")
;; (find-pil3page (+ 19 323) "31.2 Lua States")
;; (find-pil3page (+ 19 331) "Exercises")
;; (find-pil3page (+ 19 333) "32 Memory Management")
;; (find-pil3page (+ 19 333) "32.1 The Allocation Function")
;; (find-pil3page (+ 19 335) "32.2 The Garbage Collector")
;; (find-pil3page (+ 19 338) "Exercises")
;; (find-pil3page (+ 19 339) "Index")
;; (find-pil3text "")
;; (find-pil2page 8 "Contents")
;; (find-pil2page (+ 19 1) "I. The Language")
;; (find-pil2page (+ 19 3) "1. Getting Started")
;; (find-pil2page (+ 19 9) "2. Types and Values")
;; (find-pil2page (+ 19 19) "3. Expressions")
;; (find-pil2page (+ 19 27) "4. Statements")
;; (find-pil2page (+ 19 35) "5. Functions")
;; (find-pil2page (+ 19 41) "Lua 5.0" "..." "arg" "n field")
;; (find-pil2page (+ 19 45) "6. More About Functions")
;; (find-pil2page (+ 19 55) "7. Iterators and the Generic for")
;; (find-pil2page (+ 19 63) "8. Compilation, Execution, and Errors")
;; (find-pil2page (+ 19 70) "8.5 Error Messages and Tracebacks")
;; (find-pil2text (+ 19 70) "8.5 Error Messages and Tracebacks")
;; (find-pil2page (+ 19 73) "9. Coroutines")
;; (find-pil2page (+ 19 87) "10. Complete Examples")
;; (find-pil2page (+ 19 95) "II. Tables and Objects")
;; (find-pil2page (+ 19 97) "11. Data Structures")
;; (find-pil2page (+ 19 107) "12. Data Files and Persistence")
;; (find-pil2page (+ 19 117) "13. Metatables and Metamethods")
;; (find-pil2page (+ 19 129) "14. The Environment")
;; (find-pil2page (+ 19 137) "15. Modules and Packages")
;; (find-pil2page (+ 19 138) "15.1 The require Function")
;; (find-pil2text (+ 19 138) "15.1 The require Function")
;; (find-pil2page (+ 19 149) "16. Object-Oriented Programming")
;; (find-pil2page (+ 19 161) "17. Weak Tables")
;; (find-pil2page (+ 19 167) "III. The Standard Libraries")
;; (find-pil2page (+ 19 169) "18. The Mathematical Library")
;; (find-pil2page (+ 19 171) "19. The Table Library")
;; (find-pil2page (+ 19 175) "20. The String Library")
;; (find-pil2page (+ 19 193) "21. The I/O Library")
;; (find-pil2page (+ 19 201) "22. The Operating System Library")
;; (find-pil2page (+ 19 205) "23. The Debug Library")
;; (find-pil2page (+ 19 215) "IV. The C API")
;; (find-pil2page (+ 19 217) "24. An Overview of the C API")
;; (find-pil2page (+ 19 223) "lua_type")
;; (find-pil2page (+ 19 229) "25. Extending Your Application")
;; (find-pil2page (+ 19 241) "26. Calling C from Lua")
;; (find-pil2page (+ 19 244) "26.1. C Functions")
;; (find-pil2page (+ 19 244) "26.2. C Modules")
;; (find-pil2page (+ 19 247) "27. Techniques for Writing C Functions")
;; (find-pil2page (+ 19 259) "28. User-Defined Types in C")
;; (find-pil2page (+ 19 269) "29. Managing Resources")
;; (find-pil2page (+ 19 281) "30. Threads and States")
;; (find-pil2page (+ 19 293) "31. Memory Management")
;; (find-pil2page (+ 19 299) "Index")
;; (find-pil2text "")
;; «impagliazzo» (to ".impagliazzo")
;; (find-books "__comp/__comp.el" "impagliazzo")
(code-pdf-page "fiveworlds" "~/books/__comp/impagliazzo__a_personal_view_of_average-case_complexity.pdf")
(code-pdf-text "fiveworlds" "~/books/__comp/impagliazzo__a_personal_view_of_average-case_complexity.pdf" 1)
;; (find-fiveworldspage)
;; (find-fiveworldstext "")
;; (find-fiveworldspage 3 "2.1 Algorithmica")
;; (find-fiveworldstext 3 "2.1 Algorithmica")
;; (find-fiveworldspage 5 "2.2 Heuristica")
;; (find-fiveworldstext 5 "2.2 Heuristica")
;; (find-fiveworldspage 6 "2.3 Pessiland")
;; (find-fiveworldstext 6 "2.3 Pessiland")
;; (find-fiveworldspage 7 "2.4 Minicrypt")
;; (find-fiveworldstext 7 "2.4 Minicrypt")
;; (find-fiveworldspage 8 "2.5 Cryptomania")
;; (find-fiveworldstext 8 "2.5 Cryptomania")
;; «kavvos» (to ".kavvos")
;; G. A. Kavvos: Intensionality, Intensional Recursion, and the Gödel-Löb axiom
;; https://arxiv.org/abs/1703.01288
;; https://arxiv.org/pdf/1703.01288.pdf
(code-pdf-page "kavvos" "$S/https/arxiv.org/pdf/1703.01288.pdf")
(code-pdf-text "kavvos" "$S/https/arxiv.org/pdf/1703.01288.pdf")
;; (find-kavvospage)
;; (find-kavvostext)
;; «kernighan-plauger» (to ".kernighan-plauger")
;; (find-books "__comp/__comp.el" "kernighan-plauger")
;; https://en.wikipedia.org/wiki/The_Elements_of_Programming_Style
(code-pdf-page "kernighanp" "~/books/__comp/kernighan_plauger__the_elements_of_programming_style.pdf")
(code-pdf-text "kernighanp" "~/books/__comp/kernighan_plauger__the_elements_of_programming_style.pdf" 13)
;; (find-kernighanppage)
;; (find-kernighanppage 6 "Contents")
;; (find-kernighanppage (+ 13 1) "1. Introduction")
;; (find-kernighanppage (+ 13 2) "Write clearly")
;; (find-kernighanptext (+ 13 2) "Write clearly")
;; (find-kernighanppage (+ 13 9) "2. Expression")
;; (find-kernighanppage (+ 13 31) "3. Control structure")
;; (find-kernighanppage (+ 13 52) "Choose a data representation" "that makes the program simple")
;; (find-kernighanptext (+ 13 52) "Choose a data representation" "that makes the program simple")
;; (find-kernighanppage (+ 13 59) "4. Program structure")
;; (find-kernighanppage (+ 13 83) "5. Input and output")
;; (find-kernighanppage (+ 13 101) "6. Common blunders")
;; (find-kernighanppage (+ 13 123) "7. Efficiency and instrumentation")
;; (find-kernighanppage (+ 13 141) "8. Documentation")
;; (find-kernighanppage (+ 13 155) "Epilogue")
;; (find-kernighanppage (+ 13 157) "Supplementary Reading")
;; (find-kernighanppage (+ 13 159) "Summary of rules")
;; (find-kernighanppage (+ 13 163) "Index")
;; (find-kernighanptext "")
(code-pdf-page "kernighanpst" "~/books/__comp/kernighan_plauger__software_tools.pdf")
(code-pdf-text "kernighanpst" "~/books/__comp/kernighan_plauger__software_tools.pdf" 1)
;; (find-kernighanpstpage)
;; (find-kernighanpstpage 7 "Contents")
;; (find-kernighanpstpage (+ 7 1) "Introduction")
;; (find-kernighanpstpage (+ 7 7) "1. Getting started")
;; (find-kernighanpsttext "")
(code-pdf-page "kernighanpstpas" "~/books/__comp/kernighan_plauger__software_tools_in_pascal.pdf")
(code-pdf-text "kernighanpstpas" "~/books/__comp/kernighan_plauger__software_tools_in_pascal.pdf" 1)
;; (find-kernighanpstpaspage)
;; (find-kernighanpstpaspage 1 "Contents")
;; (find-kernighanpstpaspage (+ 1 189) "Index")
;; (find-kernighanpstpastext "")
;; «kernighan-ritchie» (to ".kernighan-ritchie")
;; (find-es "anatocc" "K-and-R")
(code-pdf-page "kandr" "~/usrc/the-c-programming-language/all.pdf")
(code-pdf-text "kandr" "~/usrc/the-c-programming-language/all.pdf")
;; (find-kandrpage)
;; (find-kandrtext)
;; (find-kandrpage 133 "5.11 Pointers to Functions")
;; (find-kandrtext 133 "5.11 Pointers to Functions")
;; (find-kandrpage 214 "A.5 Objects and Lvalues")
;; (find-kandrtext 214 "A.5 Objects and Lvalues")
;; (find-kandrpage 260 "A.13 Grammar")
;; (find-kandrtext 260 "A.13 Grammar")
;; (find-kandrpage 265 "additive-expression:")
;; (find-kandrtext 265 "additive-expression:")
;; «knuth» (to ".knuth")
(code-djvu "knuthlitprog" "~/books/__comp/knuth__literate_programming.djvu")
(code-djvutotext "knuthlitprog" "~/books/__comp/knuth__literate_programming.djvu")
;; (find-knuthlitprogpage 1 "Contents")
;; (find-knuthlitprogpage (+ 0 359) "Index")
;; (find-knuthlitprogtext "")
;; «kruskal-landwehr» (to ".kruskal-landwehr")
;; (find-books "__comp/__comp.el" "kruskal-landwehr")
;; https://www.jstor.org/stable/2685881
(code-pdf-page "icicleplots" "~/books/__comp/kruskal_landwehr__icicle_plots_better_displays_for_hierarchical_clustering.pdf")
(code-pdf-text "icicleplots" "~/books/__comp/kruskal_landwehr__icicle_plots_better_displays_for_hierarchical_clustering.pdf" 1)
;; (find-icicleplotspage)
;; (find-icicleplotspage 1 "Contents")
;; (find-icicleplotspage (+ 1 189) "Index")
;; (find-icicleplotstext "")
;; «kurt» (to ".kurt")
;; (find-books "__comp/__comp.el" "kurt")
(code-pdf-page "gethaskell" "~/books/__comp/kurt__get_programming_with_haskell.pdf")
(code-pdf-text "gethaskell" "~/books/__comp/kurt__get_programming_with_haskell.pdf" 1)
;; (find-gethaskellpage)
;; (find-gethaskellpage 1 "Contents")
;; (find-gethaskellpage (+ 1 189) "Index")
;; (find-gethaskelltext "")
;; «levy» (to ".levy")
;; (find-books "__comp/__comp.el" "levy")
(code-pdf "CBPV" "~/books/__comp/levy__call-by-push-value.pdf")
(code-pdftotext "CBPV" "~/books/__comp/levy__call-by-push-value.pdf" 37)
;; (find-CBPVpage)
;; (find-CBPVpage 6 "Contents")
;; (find-CBPVtext 6 "Contents")
;; (find-CBPVpage (+ 37 3) "1. Call-by-Value and Call-by-Name")
;; (find-CBPVpage (+ 37 8) "1.5 The Principles Of Call-By-Value and Call-By-Name")
;; (find-CBPVpage (+ 37 10) "1.6 Call-By-Value")
;; (find-CBPVpage (+ 37 18) "1.7 Call-By-Name")
;; (find-CBPVpage (+ 37 20) "1.7.3 CBN vs. Lazy")
;; (find-CBPVpage (+ 37 27) "2. Call-By-Push-Value: A Subsuming Paradigm")
;; (find-CBPVpage (+ 37 32) "2.3.2 CK-Machine")
;; (find-CBPVpage (+ 29 337) "References")
;; (find-CBPVtext (+ 29 337) "References")
;; (find-CBPVpage (+ 28 345) "Index")
;; (find-CBPVpage (+ 28 347) "Index" "dismantling")
;; (find-CBPVtext "")
;; "What is a monoid? How I learnt to stop worrying and love skewness":
;; http://conferences.inf.ed.ac.uk/ct2019/slides/83.pdf
;; «levy-slides2018» (to ".levy-slides2018")
;; (find-books "__comp/__comp.el" "levy-slides2018")
;; https://www.cs.bham.ac.uk/~pbl/
;; https://www.cs.bham.ac.uk/~pbl/mgsfastlam.pdf
;; "lambda-calculus, effects and call-by-push-value" (slides, 2018)
(code-pdf-page "pbl2018" "$S/https/www.cs.bham.ac.uk/~pbl/mgsfastlam.pdf")
(code-pdf-text "pbl2018" "$S/https/www.cs.bham.ac.uk/~pbl/mgsfastlam.pdf")
;; (find-pbl2018page)
;; (find-pbl2018text)
;; (find-pbl2018page 8 "Typing rules for bool")
;; (find-pbl2018text 8 "Typing rules for bool")
;; (find-pbl2018page 72 "Evaluation order for let")
;; (find-pbl2018text 72 "Evaluation order for let")
;; (find-pbl2018page 85 "Where this story comes from")
;; (find-pbl2018text 85 "Where this story comes from")
;; (find-pbl2018page 86 "Let E = {CRASH, BANG} be a set of \"errors\"")
;; (find-pbl2018text 86 "Let E = {CRASH, BANG} be a set of \"errors\"")
;; (find-pbl2018page 109 "Fine-Grain Call-By-Value")
;; (find-pbl2018text 109 "Fine-Grain Call-By-Value")
;; (find-pbl2018page 118 "Nullary functions" "thunks")
;; (find-pbl2018text 118 "Nullary functions" "thunks")
;; (find-pbl2018page 124 "Solution: E-pointed sets")
;; (find-pbl2018text 124 "Solution: E-pointed sets")
;; (find-pbl2018page 129 "Notation for E-pointed sets")
;; (find-pbl2018text 129 "Notation for E-pointed sets")
;; (find-pbl2018page 130 "Summary of call-by-name semantics")
;; (find-pbl2018text 130 "Summary of call-by-name semantics")
;; (find-pbl2018page 131 "Summary of call-by-value semantics")
;; (find-pbl2018text 131 "Summary of call-by-value semantics")
;; (find-pbl2018page 134 "Call-By-Push-Value Types")
;; (find-pbl2018text 134 "Call-By-Push-Value Types")
;; (find-pbl2018page 139 "The type F A")
;; (find-pbl2018text 139 "The type F A")
;; (find-pbl2018page 141 "The type U B")
;; (find-pbl2018text 141 "The type U B")
;; (find-pbl2018page 152 "Decomposing CBV into CBPV")
;; (find-pbl2018text 152 "Decomposing CBV into CBPV")
;; (find-pbl2018page 154 "Decomposing CBN into CBPV")
;; (find-pbl2018text 154 "Decomposing CBN into CBPV")
;; (find-pbl2018page 188 "Adjunction between values and stacks")
;; (find-pbl2018text 188 "Adjunction between values and stacks")
;; (find-pbl2018page 224 "Summary: adjunctions between values and stacks")
;; (find-pbl2018text 224 "Summary: adjunctions between values and stacks")
;; «levy-thpartsets» (to ".levy-thpartsets")
;; "A Theory of Particular Sets" (2019):
;; https://arxiv.org/abs/1905.02718
;; https://arxiv.org/pdf/1905.02718.pdf
(code-pdf-page "levytpartsets" "$S/https/arxiv.org/pdf/1905.02718.pdf")
(code-pdf-text "levytpartsets" "$S/https/arxiv.org/pdf/1905.02718.pdf")
;; (find-levytpartsetspage)
;; (find-levytpartsetstext)
;; «levy-lambdanotes» (to ".levy-lambdanotes")
;; Paul Blain Levy: "Typed lambda-calculus: course notes"
;; https://www.cs.bham.ac.uk/~pbl/mgsall.pdf
(code-pdf-page "pbllambdanotes" "$S/https/www.cs.bham.ac.uk/~pbl/mgsall.pdf")
(code-pdf-text "pbllambdanotes" "$S/https/www.cs.bham.ac.uk/~pbl/mgsall.pdf")
;; (find-pbllambdanotespage)
;; (find-pbllambdanotestext)
;; «libes» (to ".libes")
(code-xpdf "eexpect" "~/books/__comp/libes__exploring_expect.pdf")
(code-pdf-text "eexpect" "~/books/__comp/libes__exploring_expect.pdf")
;; (find-eexpectpage)
;; (find-eexpectpage 2)
;; (find-eexpectpage 9 "Chapters")
;; (find-eexpecttext)
;; «loeliger» (to ".loeliger")
;; (find-books "__comp/__comp.el" "loeliger")
;; https://archive.org/stream/R.G.LoeligerThreadedInterpretiveLanguagesTheirDesignAndImplementationByteBooks1981
(code-pdf-page "loeligertils" "~/books/__comp/loeliger__threaded_interpretive_languages_their_design_and_implementation.pdf")
(code-pdf-text "loeligertils" "~/books/__comp/loeliger__threaded_interpretive_languages_their_design_and_implementation.pdf" 1)
;; (find-loeligertilspage)
;; (find-loeligertilspage 8 "Contents")
;; (find-loeligertilspage (+ 15 1) "1. OVERVIEW")
;; (find-loeligertilspage (+ 15 1) "1.1 Introduction")
;; (find-loeligertilspage (+ 15 2) "1.2 What is a TIL?")
;; (find-loeligertilspage (+ 15 3) "1.3 The Elements")
;; (find-loeligertilspage (+ 15 6) "1.4 The Attributes")
;; (find-loeligertilspage (+ 15 7) "1.5 Implementation Notes")
;; (find-loeligertilspage (+ 15 9) "2. HOW A TIL WORKS")
;; (find-loeligertilspage (+ 15 9) "2.1 Operator's View")
;; (find-loeligertilspage (+ 15 12) "2.2 Dictionary Format")
;; (find-loeligertilspage (+ 15 14) "2.3 Outer Interpreter")
;; (find-loeligertilspage (+ 15 18) "2.4 Inner Interpreter")
;; (find-loeligertilspage (+ 15 21) "2.5 Defining Words and the Compiler Mode")
;; (find-loeligertilspage (+ 15 25) "2.6 Vocabularies")
;; (find-loeligertilspage (+ 15 26) "2.7 Synthesis")
;; (find-loeligertilspage (+ 15 28) "3. HUP, TWO, THREE, FOUR")
;; (find-loeligertilspage (+ 15 28) "3.1 An Inner Interpreter for a Generic Computer")
;; (find-loeligertilspage (+ 15 32) "3.2 An Inner Interpreter for the Z80")
;; (find-loeligertilspage (+ 15 38) "3.3 Double Time")
;; (find-loeligertilspage (+ 15 39) "4. THE TOWER OF BABEL REVISITED")
;; (find-loeligertilspage (+ 15 39) "4.1 Naming Conventions")
;; (find-loeligertilspage (+ 15 40) "4.2 Data Types")
;; (find-loeligertilspage (+ 15 48) "4.3 Operator Keywords")
;; (find-loeligertilspage (+ 15 72) "4.6 Vocabulary Keywords")
;; (find-loeligertilspage (+ 15 73) "4.7 Babblings")
;; (find-loeligertilspage (+ 15 74) "ROUTINES, ROUTINES, ROUTINES")
;; (find-loeligertilspage (+ 15 74) "5.1 Core TIL Design Notes")
;; (find-loeligertilspage (+ 15 77) "5.2 Outer Interpreter Design")
;; (find-loeligertilspage (+ 15 87) "5.3 Routine Routines")
;; (find-loeligertilspage (+ 15 99) "5.4 Doing It")
;; (find-loeligertilspage (+ 15 100) "5.5 Arithmetic Routines")
;; (find-loeligertilspage (+ 15 103) "WORDS, WORDS, AND MORE WORDS")
;; (find-loeligertilspage (+ 15 103) "6.1 The Word")
;; (find-loeligertilspage (+ 15 174) "6.2 A Classy Cross Reference")
;; (find-loeligertilspage (+ 15 179) "6.3 Sum Total")
;; (find-loeligertilspage (+ 15 180) "7. EXTENSION PLEASE")
;; (find-loeligertilspage (+ 15 180) "7.1 Introductions")
;; (find-loeligertilspage (+ 15 182) "7.2 Assemblers")
;; (find-loeligertilspage (+ 15 210) "7.3 Virtual Memory")
;; (find-loeligertilspage (+ 15 220) "7.4 Editor")
;; (find-loeligertilspage (+ 15 224) "7.5 Cross Compilation")
;; (find-loeligertilspage (+ 15 226) "7.6 Widget Sorters")
;; (find-loeligertilspage (+ 15 228) "7.7 Floatingpoint")
;; (find-loeligertilspage (+ 15 233) "7.8 Extension Summary")
;; (find-loeligertilspage (+ 15 234) "LIFE WITH A TIL")
;; (find-loeligertilspage (+ 15 234) "8.1 Starting Out")
;; (find-loeligertilspage (+ 15 235) "8.2 Program Structure")
;; (find-loeligertilspage (+ 15 239) "8.3 Program Design")
;; (find-loeligertilspage (+ 15 241) "8.4 Entry and Test")
;; (find-loeligertilspage (+ 15 243) "8.5 Tricks of the Trade")
;; (find-loeligertilspage (+ 15 244) "Bibliography and Notes")
;; (find-loeligertilspage (+ 15 248) "Index")
;; (find-loeligertilstext "")
;; «marlow-peyton-jones» (to ".marlow-peyton-jones")
;; (find-books "__comp/__comp.el" "marlow-peyton-jones")
;; https://link.springer.com/chapter/10.1007/978-1-4471-3215-8_6
(code-pdf-page "mpjretrosp" "~/books/__comp/marlow_peyton-jones__the_glasgow_haskell_compiler_a_retrospective.pdf")
(code-pdf-text "mpjretrosp" "~/books/__comp/marlow_peyton-jones__the_glasgow_haskell_compiler_a_retrospective.pdf" 1)
;; (find-mpjretrosppage)
;; (find-mpjretrosppage 1 "Contents")
;; (find-mpjretrosppage (+ 1 189) "Index")
;; (find-mpjretrosptext "")
;; (find-mpjretrosppage 9 "2.3.4 Desugaring, and the Core language")
;; (find-mpjretrosptext 9 "2.3.4 Desugaring, and the Core language")
;; (find-mpjretrosppage 11 "3.1 The intermediate language")
;; (find-mpjretrosptext 11 "3.1 The intermediate language")
;; «martin» (to ".martin")
;; (find-books "__comp/__comp.el" "martin")
(code-pdf-page "cleancode" "~/books/__comp/martin__clean_code_a_handbook_of_agile_software_craftsmanship.pdf")
(code-pdf-text "cleancode" "~/books/__comp/martin__clean_code_a_handbook_of_agile_software_craftsmanship.pdf" 1)
;; (find-cleancodepage)
;; (find-cleancodepage 1 "Contents")
;; (find-cleancodepage (+ 1 189) "Index")
;; (find-cleancodetext "")
;; «massot-why» (to ".massot-why")
;; (find-books "__comp/__comp.el" "massot-why")
;; https://www.imo.universite-paris-saclay.fr/~pmassot/files/exposition/why_formalize.pdf
(code-pdf-page "massotwhy" "$S/https/www.imo.universite-paris-saclay.fr/~pmassot/files/exposition/why_formalize.pdf")
(code-pdf-text "massotwhy" "$S/https/www.imo.universite-paris-saclay.fr/~pmassot/files/exposition/why_formalize.pdf")
;; (find-massotwhypage)
;; (find-massotwhytext)
;; (find-massotwhypage 6 "sequence_tendsto")
;; (find-massotwhytext 6 "sequence_tendsto")
;; «mcbride» (to ".mcbride")
;; (find-books "__comp/__comp.el" "mcbride")
;; http://strictlypositive.org/
;; http://strictlypositive.org/calculus/
;; http://strictlypositive.org/vfl.pdf
(code-pdf-page "viewfromtheleft" "$S/http/strictlypositive.org/vfl.pdf")
(code-pdf-text "viewfromtheleft" "$S/http/strictlypositive.org/vfl.pdf")
;; (find-viewfromtheleftpage)
;; (find-viewfromtheleftpage 44 "References")
;; (find-viewfromthelefttext)
;; «mcbride-pivotal» (to ".mcbride-pivotal")
;; (find-books "__comp/__comp.el" "mcbride-pivotal")
;; (find-es "agda" "pivotal")
;; https://personal.cis.strath.ac.uk/conor.mcbride/Pivotal.pdf
(code-pdf-page "mcbride-pivotal" "$S/https/personal.cis.strath.ac.uk/conor.mcbride/Pivotal.pdf")
(code-pdf-text "mcbride-pivotal" "$S/https/personal.cis.strath.ac.uk/conor.mcbride/Pivotal.pdf")
;; (find-mcbride-pivotalpage)
;; (find-mcbride-pivotaltext)
;; «mccarthy58» (to ".mccarthy58")
;; (find-books "__comp/__comp.el" "mccarthy58")
;; http://www.softwarepreservation.org/projects/LISP/MIT/AIM-001.pdf
;; https://news.ycombinator.com/item?id=14885779 An Algebraic Language for the Manipulation of Symbolic Expressions (1958)
(code-pdf-page "mccarthy58" "$S/http/www.softwarepreservation.org/projects/LISP/MIT/AIM-001.pdf")
(code-pdf-text "mccarthy58" "$S/http/www.softwarepreservation.org/projects/LISP/MIT/AIM-001.pdf")
;; (find-mccarthy58page)
;; (find-mccarthy58text)
;; «meyer» (to ".meyer")
;; (find-books "__comp/__comp.el" "meyer")
;; https://doi.org/10.1016/S0019-9958(82)80087-9
(code-pdf-page "wiamolc" "~/books/__comp/meyer__what_is_a_model_of_the_lambda_calculus.pdf")
(code-pdf-text "wiamolc" "~/books/__comp/meyer__what_is_a_model_of_the_lambda_calculus.pdf" -86)
;; (find-wiamolcpage)
;; (find-wiamolcpage (+ -86 87) "1. Introduction")
;; (find-wiamolctext (+ -86 87) "1. Introduction")
;; (find-wiamolcpage (+ -86 88) "can quickly lead to contradiction")
;; (find-wiamolctext (+ -86 88) "can quickly lead to contradiction")
;; (find-wiamolctext "")
;; «milner» (to ".milner")
;; (find-books "__comp/__comp.el" "milner")
;; (find-books "__logic/__logic.el" "logic-and-alg-spec")
;; Robin Milner: "The Polyadic pi-Calculus: a Tutorial"
;; https://www.lfcs.inf.ed.ac.uk/reports/91/ECS-LFCS-91-180/
;; https://www.lfcs.inf.ed.ac.uk/reports/91/ECS-LFCS-91-180/ECS-LFCS-91-180.ps
;; https://www.lfcs.inf.ed.ac.uk/reports/91/ECS-LFCS-91-180/ECS-LFCS-91-180.pdf
;; (find-sh "cd $S/https/www.lfcs.inf.ed.ac.uk/reports/91/ECS-LFCS-91-180/ && ps2pdf ECS-LFCS-91-180.ps")
(code-pdf-page "polypiput" "$S/https/www.lfcs.inf.ed.ac.uk/reports/91/ECS-LFCS-91-180/ECS-LFCS-91-180.pdf")
(code-pdf-text "polypiput" "$S/https/www.lfcs.inf.ed.ac.uk/reports/91/ECS-LFCS-91-180/ECS-LFCS-91-180.pdf")
;; (find-polypiputpage)
;; (find-polypiputtext)
;; «monnier» (to ".monnier")
;; (find-books "__comp/__comp.el" "monnier")
(code-pdf-page "typintla" "~/books/__comp/shao_league_monnier__implementing_typed_intermediate_languages.pdf")
(code-pdf-text "typintla" "~/books/__comp/shao_league_monnier__implementing_typed_intermediate_languages.pdf" 1)
;; (find-typintlapage)
;; (find-typintlapage 1 "Contents")
;; (find-typintlapage (+ 1 189) "Index")
;; (find-typintlatext "")
;;
;; «monnier-typer» (to ".monnier-typer")
;; (find-books "__comp/__comp.el" "monnier-typer")
;; (find-es "ocaml" "typer")
;; http://www.iro.umontreal.ca/~monnier/typer-jfla2019.pdf
(code-pdf-page "monniertyper" "$S/http/www.iro.umontreal.ca/~monnier/typer-jfla2019.pdf")
(code-pdf-text "monniertyper" "$S/http/www.iro.umontreal.ca/~monnier/typer-jfla2019.pdf")
;; (find-monniertyperpage)
;; (find-monniertypertext)
;; (find-monniertyperpage 15 "References")
;; (find-monniertypertext 15 "References")
;; (find-monniertyperpage 16 "[Flo63]" "operator precedence")
;; (find-monniertypertext 16 "[Flo63]" "operator precedence")
;;
;; «monnier-cuc» (to ".monnier-cuc")
;; (find-books "__comp/__comp.el" "monnier-cuc")
;; "Inductive Types Deconstructed: The Calculus of United Constructions" (2019)
;; http://www.iro.umontreal.ca/~monnier/itd-tyde-2019.pdf
(code-pdf-page "monniercuc" "$S/http/www.iro.umontreal.ca/~monnier/itd-tyde-2019.pdf")
(code-pdf-text "monniercuc" "$S/http/www.iro.umontreal.ca/~monnier/itd-tyde-2019.pdf" -51)
;; (find-monniercucpage)
;; (find-monniercuctext)
;; (find-monniercucpage (+ -51 61) "Figure 12. Mapping CUC to CIC")
;; (find-monniercuctext (+ -51 61) "Figure 12. Mapping CUC to CIC")
;;
;; «monnier-smie» (to ".monnier-smie")
;; (find-books "__comp/__comp.el" "monnier-smie")
;; http://www.iro.umontreal.ca/~monnier/smie.pdf
(code-pdf-page "monniersmie" "$S/http/www.iro.umontreal.ca/~monnier/smie.pdf")
(code-pdf-text "monniersmie" "$S/http/www.iro.umontreal.ca/~monnier/smie.pdf")
;; (find-monniersmiepage)
;; (find-monniersmietext)
;; «monnier-evol» (to ".monnier-evol")
;; Monnier/Sperber: "Evolution of Emacs Lisp"
;; https://dl.acm.org/doi/pdf/10.1145/3386324
;; (find-fline "$S/https/dl.acm.org/doi/pdf/10.1145/")
(code-pdf-page "monnierevol" "$S/https/dl.acm.org/doi/pdf/10.1145/3386324")
(code-pdf-text "monnierevol" "$S/https/dl.acm.org/doi/pdf/10.1145/3386324")
;; (find-monnierevolpage)
;; (find-monnierevoltext)
;; «nanevski» (to ".nanevski")
;; (find-books "__comp/__comp.el" "nanevski")
;; https://software.imdea.org/~aleks/
;; https://software.imdea.org/~aleks/thesis/CMU-CS-04-151.pdf
;; Aleksandar Nanevski: "Functional Programming with Names and Necessity" (PhD thesis, 2004)
(code-pdf-page "nanevskiphd" "$S/https/software.imdea.org/~aleks/thesis/CMU-CS-04-151.pdf")
(code-pdf-text "nanevskiphd" "$S/https/software.imdea.org/~aleks/thesis/CMU-CS-04-151.pdf")
;; (find-nanevskiphdpage)
;; (find-nanevskiphdtext)
;;
;; Aleksandar Nanevski: "A Modal Calculus for Effect Handling" (2003)
;; https://software.imdea.org/~aleks/papers/effects/CMU-CS-03-149.pdf
(code-pdf-page "nanevskimceh" "$S/https/software.imdea.org/~aleks/papers/effects/CMU-CS-03-149.pdf")
(code-pdf-text "nanevskimceh" "$S/https/software.imdea.org/~aleks/papers/effects/CMU-CS-03-149.pdf")
;; (find-nanevskimcehpage)
;; (find-nanevskimcehtext)
;;
;; Nanevski/Morrisett/Birkedal: "Polymorphism and Separation in Hoare Type Theory" (2006)
;; https://software.imdea.org/~aleks/papers/hoarelogic/icfp06.pdf
(code-pdf-page "nanevskipshtt" "$S/https/software.imdea.org/~aleks/papers/hoarelogic/icfp06.pdf")
(code-pdf-text "nanevskipshtt" "$S/https/software.imdea.org/~aleks/papers/hoarelogic/icfp06.pdf")
;; (find-nanevskipshttpage)
;; (find-nanevskipshtttext)
;; «norell» (to ".norell")
;; (find-books "__comp/__comp.el" "norell")
;; (find-books "__comp/__comp.el" "chapman")
;; http://www.cse.chalmers.se/~ulfn/
;; https://twitter.com/ulfnorell?lang=en
;; http://doi.org/10.1145/2500365.2500609
;;
;; Ulf Norell: "Towards a practical programming language based on
;; dependent type theory" (PhD Thesis, 2007, about Agda)
;; https://en.wikiversity.org/wiki/Foundations_of_Functional_Programming/UTT-%CE%A3
;; http://www.cse.chalmers.se/~ulfn/papers/thesis.html
;; http://www.cse.chalmers.se/~ulfn/papers/thesis.pdf
(code-pdf-page "norellphd" "$S/http/www.cse.chalmers.se/~ulfn/papers/thesis.pdf")
(code-pdf-text "norellphd" "$S/http/www.cse.chalmers.se/~ulfn/papers/thesis.pdf")
;; (find-norellphdpage)
;; (find-norellphdtext)
;; (find-norellphdpage 7 "Contents")
;; (find-norellphdtext 7 "Contents")
;; (find-norellphdpage 15 "Figure 1.1: The syntax of UTT_Sigma")
;; (find-norellphdtext 15 "Figure 1.1: The syntax of UTT")
;; (find-norellphdpage 32 "2.1.4 Unification")
;; (find-norellphdtext 32 "2.1.4 Unification")
;; «norell-chapman» (to ".norell-chapman")
;; Norell/Chapman: "Dependently Typed Programming in Agda" (41 pages)
;; http://www.cse.chalmers.se/~ulfn/papers/afp08/tutorial.pdf
(code-pdf-page "norellch" "$S/http/www.cse.chalmers.se/~ulfn/papers/afp08/tutorial.pdf")
(code-pdf-text "norellch" "$S/http/www.cse.chalmers.se/~ulfn/papers/afp08/tutorial.pdf")
;; (find-norellchpage)
;; (find-norellchtext)
;; (find-norellchpage 1 "1 Introduction")
;; (find-norellchtext 1 "1 Introduction")
;; (find-norellchpage 1 "2 Agda Basics")
;; (find-norellchtext 1 "2 Agda Basics")
;; (find-norellchpage 2 "2.1 Datatypes and pattern matching")
;; (find-norellchtext 2 "2.1 Datatypes and pattern matching")
;; (find-norellchpage 4 "2.2 Dependent functions")
;; (find-norellchtext 4 "2.2 Dependent functions")
;; (find-norellchpage 5 "2.3 Implicit arguments")
;; (find-norellchtext 5 "2.3 Implicit arguments")
;; (find-norellchpage 7 "2.4 Datatype families")
;; (find-norellchtext 7 "2.4 Datatype families")
;; (find-norellchpage 11 "2.5 Programs as proofs")
;; (find-norellchtext 11 "2.5 Programs as proofs")
;; (find-norellchpage 12 "2.6 More on pattern matching")
;; (find-norellchtext 12 "2.6 More on pattern matching")
;; (find-norellchpage 15 "2.7 Modules")
;; (find-norellchtext 15 "2.7 Modules")
;; (find-norellchpage 18 "2.8 Records")
;; (find-norellchtext 18 "2.8 Records")
;; (find-norellchpage 19 "2.9 Exercises")
;; (find-norellchtext 19 "2.9 Exercises")
;; (find-norellchpage 21 "3 Programming Techniques")
;; (find-norellchtext 21 "3 Programming Techniques")
;; (find-norellchpage 21 "3.1 Views")
;; (find-norellchtext 21 "3.1 Views")
;; (find-norellchpage 29 "3.2 Universes")
;; (find-norellchtext 29 "3.2 Universes")
;; (find-norellchpage 34 "3.3 Exercises")
;; (find-norellchtext 34 "3.3 Exercises")
;; (find-norellchpage 38 "4 Compiling Agda programs")
;; (find-norellchtext 38 "4 Compiling Agda programs")
;; (find-norellchpage 38 "4.1 Relating Agda types to Haskell types")
;; (find-norellchtext 38 "4.1 Relating Agda types to Haskell types")
;; (find-norellchpage 39 "4.2 Importing Haskell functions")
;; (find-norellchtext 39 "4.2 Importing Haskell functions")
;; (find-norellchpage 39 "4.3 Our first program")
;; (find-norellchtext 39 "4.3 Our first program")
;; (find-norellchpage 39 "4.4 Haskell module imports")
;; (find-norellchtext 39 "4.4 Haskell module imports")
;; (find-norellchpage 40 "4.5 Importing polymorphic functions")
;; (find-norellchtext 40 "4.5 Importing polymorphic functions")
;; (find-norellchpage 40 "4.6 Exercises")
;; (find-norellchtext 40 "4.6 Exercises")
;; (find-norellchpage 40 "5 Further reading")
;; (find-norellchtext 40 "5 Further reading")
;; «norell-bo» (to ".norell-bo")
;; (find-books "__comp/__comp.el" "norell-bo")
;; (find-LATEX "catsem-ab.bib" "bib-Norell09")
;; Bove/Dybjer/Norell: "A Brief Overview of Agda - A Functional Language with Dependent Types" (2009)
;; http://www.cse.chalmers.se/~ulfn/papers/tphols09/tutorial.pdf
(code-pdf-page "agdatut09" "$S/http/www.cse.chalmers.se/~ulfn/papers/tphols09/tutorial.pdf")
(code-pdf-text "agdatut09" "$S/http/www.cse.chalmers.se/~ulfn/papers/tphols09/tutorial.pdf")
;; (find-agdatut09page)
;; (find-agdatut09text)
;; (find-agdatut09page 1 "1 Introduction")
;; (find-agdatut09text 1 "1 Introduction")
;; (find-agdatut09page 2 "2 Agda Features")
;; (find-agdatut09text 2 "2 Agda Features")
;; (find-agdatut09page 3 "3 Agda and some Related Languages")
;; (find-agdatut09text 3 "3 Agda and some Related Languages")
;; (find-agdatut09page 3 "4 Example: Equational Proofs in Commutative Monoids")
;; (find-agdatut09text 3 "4 Example: Equational Proofs in Commutative Monoids")
;; (find-agdatut09page 6 "References")
;; (find-agdatut09text 6 "References")
;; "Type checking in the presence of meta-variables":
;; http://www.cse.chalmers.se/~ulfn/papers/meta-variables.pdf
;; (find-books "__comp/__comp.el" "norell")
;; https://doi.org/10.1145/2500365.2500610 (one page long)
(code-pdf-page "norellipdt" "~/books/__comp/norell__interactive_programming_with_dependent_types.pdf")
(code-pdf-text "norellipdt" "~/books/__comp/norell__interactive_programming_with_dependent_types.pdf" 1)
;; (find-norellipdtpage)
;; (find-norellipdtpage 1 "Contents")
;; (find-norellipdtpage (+ 1 189) "Index")
;; (find-norellipdttext "")
;; "Dependently Typed Programming in Agda"
;; https://link.springer.com/chapter/10.1007/978-3-642-04652-0_5
;; «orchard» (to ".orchard")
;; (find-books "__comp/__comp.el" "orchard")
;; https://www.cs.kent.ac.uk/people/staff/dao7/
;; Orchard/Mycroft: "Categorical Programming for Data Types with Restricted Parametricity"
;; https://www.doc.ic.ac.uk/~dorchard/drafts/tfp-structures-orchard12.pdf
(code-pdf-page "orchardcprp" "$S/https/www.doc.ic.ac.uk/~dorchard/drafts/tfp-structures-orchard12.pdf")
(code-pdf-text "orchardcprp" "$S/https/www.doc.ic.ac.uk/~dorchard/drafts/tfp-structures-orchard12.pdf")
;; (find-orchardcprppage)
;; (find-orchardcprptext)
;; «orchard-rice» (to ".orchard-rice")
;; Orchard/Rice: "A computational science agenda for programming language research" (2014)
;; https://www.cs.kent.ac.uk/people/staff/dao7/publ/iccs14-orchard-rice.pdf
;; See also:
;; https://philbull.wordpress.com/2020/05/10/why-you-can-ignore-reviews-of-scientific-code-by-commercial-software-developers/
;; https://www.akitaonrails.com/2020/05/07/o-modelo-do-imperial-college-sobre-a-covid-19-pode-estar-errado
(code-pdf-page "orchardrice" "$S/https/www.cs.kent.ac.uk/people/staff/dao7/publ/iccs14-orchard-rice.pdf")
(code-pdf-text "orchardrice" "$S/https/www.cs.kent.ac.uk/people/staff/dao7/publ/iccs14-orchard-rice.pdf")
;; (find-orchardricepage)
;; (find-orchardricetext)
;; «orchard-codo» (to ".orchard-codo")
;; Orchard/Mycroft: "A Notation for Comonads"
;; https://www.cs.kent.ac.uk/people/staff/dao7/publ/codo-notation-orchard-ifl12.pdf
(code-pdf-page "orchardcodo" "$S/https/www.cs.kent.ac.uk/people/staff/dao7/publ/codo-notation-orchard-ifl12.pdf")
(code-pdf-text "orchardcodo" "$S/https/www.cs.kent.ac.uk/people/staff/dao7/publ/codo-notation-orchard-ifl12.pdf")
;; (find-orchardcodopage)
;; (find-orchardcodotext)
;; <orchard-four-Rs>
;; https://www.cs.kent.ac.uk/people/staff/dao7/publ/onwards-essay-orchard11.pdf
(code-pdf-page "orchard4rs" "$S/https/www.cs.kent.ac.uk/people/staff/dao7/publ/onwards-essay-orchard11.pdf")
(code-pdf-text "orchard4rs" "$S/https/www.cs.kent.ac.uk/people/staff/dao7/publ/onwards-essay-orchard11.pdf")
;; (find-orchard4rspage)
;; (find-orchard4rstext)
;; «ousterhout» (to ".ousterhout")
;; (find-books "__comp/__comp.el" "ousterhout")
(code-pdf-page "tcltk" "~/books/__comp/ousterhout__tcl_and_the_tk_toolkit.pdf")
(code-pdf-text "tcltk" "~/books/__comp/ousterhout__tcl_and_the_tk_toolkit.pdf" 8)
(code-pdf-text "tcltk" "~/books/__comp/ousterhout__tcl_and_the_tk_toolkit.pdf" 16)
(code-pdf-text "tcltk" "~/books/__comp/ousterhout__tcl_and_the_tk_toolkit.pdf" 20)
;; (ee-page-parameters "tcltk" 8)
;; (ee-page-parameters "tcltk" 16)
;; (find-tcltktext "")
;; (find-tcltkpage 3 "Contents")
;; (find-tcltkpage 143 "Contents")
;; (find-tcltkpage 271 "Contents")
;; (find-tcltkpage 341 "Contents")
;; (find-tcltkpage (+ 8 1) "1. Introduction")
;; (find-tcltkpage (+ 8 1) "1.1 Introduction")
;; (find-tcltkpage (+ 8 3) "1.2 Organization of the book")
;; (find-tcltkpage (+ 8 4) "1.3 Notation")
;; (find-tcltkpage (+ 8 5) "2. An Overview of Tcl and Tk")
;; (find-tcltkpage (+ 8 5) "2.1 Getting started")
;; (find-tcltkpage (+ 8 7) "2.2 Hello world with Tk")
;; (find-tcltkpage (+ 8 9) "2.3 Script files")
;; (find-tcltkpage (+ 8 10) "2.4 Variables and substitutions")
;; (find-tcltktext (+ 8 10) "2.4 Variables and substitutions")
;; (find-tcltkpage (+ 8 11) "2.5 Control structures")
;; (find-tcltkpage (+ 8 13) "2.6 Event bindings")
;; (find-tcltkpage (+ 8 15) "2.7 Subprocesses")
;; (find-tcltkpage (+ 8 18) "2.8 Additional features of Tcl and Tk")
;; (find-tcltkpage (+ 8 18) "2.9 Extensions and applications")
;; (find-tcltkpage (+ 8 19) "2.9.1 Expect")
;; (find-tcltkpage (+ 8 19) "2.9.2 Extended Tcl")
;; (find-tcltkpage (+ 8 20) "2.9.3 XF")
;; (find-tcltkpage (+ 8 20) "2.9.4 Distributed programming")
;; (find-tcltkpage (+ 8 22) "2.9.5 Ak")
;; (find-tcltkpage (+ 8 25) "3. Tcl Language Syntax")
;; (find-tcltkpage (+ 8 25) "3.1 Scripts, commands, and words")
;; (find-tcltkpage (+ 8 26) "3.2 Evaluating a command")
;; (find-tcltkpage (+ 8 28) "3.3 Variable substitution")
;; (find-tcltkpage (+ 8 29) "3.4 Command substitution")
;; (find-tcltkpage (+ 8 30) "3.5 Backslash substitution")
;; (find-tcltkpage (+ 8 30) "3.6 Quoting with double-quotes")
;; (find-tcltkpage (+ 8 32) "3.7 Quoting with braces")
;; (find-tcltkpage (+ 8 33) "3.8 Comments")
;; (find-tcltkpage (+ 8 33) "3.9 Normal and exceptional returns")
;; (find-tcltkpage (+ 8 34) "3.10 More on substitutions")
;; (find-tcltkpage (+ 8 37) "4. Variables")
;; (find-tcltkpage (+ 8 37) "4.1 Simple variables and the set command")
;; (find-tcltkpage (+ 8 38) "4.2 Arrays")
;; (find-tcltkpage (+ 8 39) "4.3 Variable substitution")
;; (find-tcltkpage (+ 8 40) "4.4 Removing variables: unset")
;; (find-tcltkpage (+ 8 41) "4.5 Multi-dimensional arrays")
;; (find-tcltkpage (+ 8 41) "4.6 The incr and append commands")
;; (find-tcltkpage (+ 8 42) "4.7 Preview of other variable facilities")
;; (find-tcltkpage (+ 8 43) "5. Expressions")
;; (find-tcltkpage (+ 8 43) "5.1 Numeric operands")
;; (find-tcltkpage (+ 8 44) "5.2 Operators and precedence")
;; (find-tcltkpage (+ 8 44) "5.2.1 Arithmetic operators")
;; (find-tcltkpage (+ 8 46) "5.2.2 Relational operators")
;; (find-tcltkpage (+ 8 46) "5.2.3 Logical operators")
;; (find-tcltkpage (+ 8 46) "5.2.4 Bitwise operators")
;; (find-tcltkpage (+ 8 46) "5.2.5 Choice operator")
;; (find-tcltkpage (+ 8 47) "5.3 Math functions")
;; (find-tcltkpage (+ 8 47) "5.4 Substitutions")
;; (find-tcltkpage (+ 8 49) "5.5 String manipulation")
;; (find-tcltkpage (+ 8 49) "5.6 Types and conversions")
;; (find-tcltkpage (+ 8 50) "5.7 Precision")
;; (find-tcltkpage (+ 8 51) "6. Lists")
;; (find-tcltkpage (+ 8 51) "6.1 Basic list structure and the lindex command")
;; (find-tcltkpage (+ 8 53) "6.2 Creating lists: concat, list, and llength")
;; (find-tcltkpage (+ 8 54) "6.3 Modifying lists: linsert, lreplace, lrange, and lappend")
;; (find-tcltkpage (+ 8 56) "6.4 Searching lists: lsearch")
;; (find-tcltkpage (+ 8 56) "6.5 Sorting lists: lsort")
;; (find-tcltkpage (+ 8 57) "6.6 Converting between strings and lists: split and join")
;; (find-tcltkpage (+ 8 58) "6.7 Lists and commands")
;; (find-tcltkpage (+ 8 61) "7. Control Flow")
;; (find-tcltkpage (+ 8 61) "7.1 The if command")
;; (find-tcltkpage (+ 8 63) "7.2 Looping commands: while, for, and foreach")
;; (find-tcltkpage (+ 8 65) "7.3 Loop control: break and continue")
;; (find-tcltkpage (+ 8 65) "7.4 The switch command")
;; (find-tcltkpage (+ 8 67) "7.5 Eval")
;; (find-tcltkpage (+ 8 68) "7.6 Executing from files: source")
;; (find-tcltkpage (+ 8 69) "8. Procedures")
;; (find-tcltkpage (+ 8 69) "8.1 Procedure basics: proc and return")
;; (find-tcltkpage (+ 8 71) "8.2 Local and global variables")
;; (find-tcltkpage (+ 8 72) "8.3 Defaults and variable numbers of arguments")
;; (find-tcltkpage (+ 8 73) "8.4 Call by reference: upvar")
;; (find-tcltkpage (+ 8 74) "8.5 Creating new control structures: uplevel")
;; (find-tcltkpage (+ 8 77) "9. Errors and Exceptions")
;; (find-tcltkpage (+ 8 77) "9.1 What happens after an error?")
;; (find-tcltkpage (+ 8 79) "9.2 Generating errors from Tcl scripts")
;; (find-tcltkpage (+ 8 80) "9.3 Trapping errors with catch")
;; (find-tcltkpage (+ 8 81) "9.4 Exceptions in general")
;; (find-tcltkpage (+ 8 85) "10. String Manipulation")
;; (find-tcltkpage (+ 8 85) "10.1 Glob-style pattern matching")
;; (find-tcltkpage (+ 8 88) "10.2 Pattern matching with regular expressions")
;; (find-tcltkpage (+ 8 90) "10.3 Using regular expressions for substitutions")
;; (find-tcltkpage (+ 8 91) "10.4 Generating strings with format")
;; (find-tcltkpage (+ 8 93) "10.5 Parsing strings with scan")
;; (find-tcltkpage (+ 8 94) "10.6 Extracting characters: string index and string range")
;; (find-tcltkpage (+ 8 94) "10.7 Searching and comparison")
;; (find-tcltkpage (+ 8 95) "10.8 Length, case conversion, and trimming")
;; (find-tcltkpage (+ 8 97) "11. Accessing Files")
;; (find-tcltkpage (+ 8 97) "11.1 File names")
;; (find-tcltkpage (+ 8 99) "11.2 Basic file I/O")
;; (find-tcltkpage (+ 8 101) "11.3 Output buffering")
;; (find-tcltkpage (+ 8 101) "11.4 Random access to files")
;; (find-tcltkpage (+ 8 102) "11.5 The current working directory")
;; (find-tcltkpage (+ 8 102) "11.6 Manipulating file names: glob and file")
;; (find-tcltkpage (+ 8 105) "11.7 File information commands")
;; (find-tcltkpage (+ 8 107) "11.8 Errors in system calls")
;; (find-tcltkpage (+ 8 109) "12. Processes")
;; (find-tcltkpage (+ 8 109) "12.1 Invoking subprocesses with exec")
;; (find-tcltkpage (+ 8 112) "12.2 I/O to and from a command pipeline")
;; (find-tcltkpage (+ 8 113) "12.3 Process ids")
;; (find-tcltkpage (+ 8 113) "12.4 Environment variables")
;; (find-tcltkpage (+ 8 113) "12.5 Terminating the Tcl process with exit")
;; (find-tcltkpage (+ 8 115) "13. Managing Tcl Internals")
;; (find-tcltkpage (+ 8 115) "13.1 Querying the elements of an array")
;; (find-tcltkpage (+ 8 117) "13.2 The info command")
;; (find-tcltkpage (+ 8 117) "13.2.1 Information about variables")
;; (find-tcltkpage (+ 8 120) "13.2.2 Information about procedures")
;; (find-tcltkpage (+ 8 121) "13.2.3 Information about commands")
;; (find-tcltkpage (+ 8 122) "13.2.4 Tclversion and library")
;; (find-tcltkpage (+ 8 122) "13.3 Timing command execution")
;; (find-tcltkpage (+ 8 123) "13.4 Tracing operations on variables")
;; (find-tcltkpage (+ 8 125) "13.5 Renaming and deleting commands")
;; (find-tcltkpage (+ 8 126) "13.6 Unknown commands")
;; (find-tcltkpage (+ 8 128) "13.7 Auto-loading")
;; (find-tcltkpage (+ 8 131) "14. History")
;; (find-tcltkpage (+ 8 131) "14.1 The history list")
;; (find-tcltkpage (+ 8 133) "14.2 Specifying events")
;; (find-tcltkpage (+ 8 133) "14.3 Re-executing commands from the history list")
;; (find-tcltkpage (+ 8 134) "14.4 Shortcuts implemented by unknown")
;; (find-tcltkpage (+ 8 134) "14.5 Current event number: history nextid")
;; (find-tcltkpage 147 "PART II: WRITING SCRIPTS FOR TK")
;; (find-tcltkpage (+ 16 133) "14. An Introduction to Tk")
;; (find-tcltkpage (+ 16 134) "14.1 Widgets and windows")
;; (find-tcltkpage (+ 16 136) "14.2 Screens, decorations, and toplevel windows")
;; (find-tcltkpage (+ 16 137) "14.3 Applications and processes")
;; (find-tcltkpage (+ 16 138) "14.4 Scripts and events")
;; (find-tcltkpage (+ 16 138) "14.5 Wish: a windowing shell")
;; (find-tcltkpage (+ 16 139) "14.6 Widget creation commands")
;; (find-tcltkpage (+ 16 140) "14.7 Geometry managers")
;; (find-tcltkpage (+ 16 141) "14.8 Widget commands")
;; (find-tcltkpage (+ 16 142) "14.9 Commands for interconnection")
;; (find-tcltkpage (+ 16 145) "15. Tour Of The Tk Widgets")
;; (find-tcltkpage (+ 16 145) "15.1 Frames and toplevels")
;; (find-tcltkpage (+ 16 146) "15.2 Labels, buttons, checkbuttons, and radiobuttons")
;; (find-tcltkpage (+ 16 148) "15.3 Menus and menubuttons")
;; (find-tcltkpage (+ 16 150) "15.3.1 Pull-down menus")
;; (find-tcltkpage (+ 16 150) "15.3.2 Pop-up menus")
;; (find-tcltkpage (+ 16 150) "15.3.3 Cascaded menus")
;; (find-tcltkpage (+ 16 151) "15.3.4 Keyboard traversal and accelerators")
;; (find-tcltkpage (+ 16 151) "15.4 Listboxes")
;; (find-tcltkpage (+ 16 152) "15.5 Entries")
;; (find-tcltkpage (+ 16 153) "15.6 Scrollbars")
;; (find-tcltkpage (+ 16 154) "15.7 Text")
;; (find-tcltkpage (+ 16 155) "15.8 Canvases")
;; (find-tcltkpage (+ 16 157) "15.9 Scales")
;; (find-tcltkpage (+ 16 157) "15.10 Messages")
;; (find-tcltkpage (+ 16 159) "16. Configuration Options")
;; (find-tcltkpage (+ 16 159) "16.1 How options are set")
;; (find-tcltkpage (+ 16 161) "16.2 Colors")
;; (find-tcltkpage (+ 16 163) "16.3 Screen distances")
;; (find-tcltkpage (+ 16 164) "16.4 Reliefs")
;; (find-tcltkpage (+ 16 164) "16.5 Fonts")
;; (find-tcltkpage (+ 16 166) "16.6 Bitmaps")
;; (find-tcltkpage (+ 16 166) "16.7 Cursors")
;; (find-tcltkpage (+ 16 167) "16.8 Anchors")
;; (find-tcltkpage (+ 16 169) "16.9 Script options and scrolling")
;; (find-tcltkpage (+ 16 171) "16.10 Variables")
;; (find-tcltkpage (+ 16 171) "16.11 Time intervals")
;; (find-tcltkpage (+ 16 171) "16.12 The configure widget command")
;; (find-tcltkpage (+ 16 173) "16.13 The option database")
;; (find-tcltkpage (+ 16 173) "16.13.1 Patterns")
;; (find-tcltkpage (+ 16 175) "16.13.2 RESOURCE_MANAGER property and .Xdefaults file")
;; (find-tcltkpage (+ 16 175) "16.13.3 Priorities")
;; (find-tcltkpage (+ 16 176) "16.13.4 The option command")
;; (find-tcltkpage (+ 16 179) "17. Geometry Managers: The Placer")
;; (find-tcltkpage (+ 16 179) "17.1 An overview of geometry management")
;; (find-tcltkpage (+ 16 182) "17.2 Controlling positions with the placer")
;; (find-tcltkpage (+ 16 185) "17.3 Controlling the size of a slave")
;; (find-tcltkpage (+ 16 185) "17.4 Selecting the master window")
;; (find-tcltkpage (+ 16 186) "17.5 Border modes")
;; (find-tcltkpage (+ 16 186) "17.6 More on the place command")
;; (find-tcltkpage (+ 16 187) "17.7 Controlling the size of the master")
;; (find-tcltkpage (+ 16 189) "18. The Packer")
;; (find-tcltkpage (+ 16 189) "18.1 Packer basics")
;; (find-tcltkpage (+ 16 193) "18.2 Packer configuration options")
;; (find-tcltkpage (+ 16 196) "18.3 Hierarchical packing")
;; (find-tcltkpage (+ 16 197) "18.4 Other options to the pack command")
;; (find-tcltkpage (+ 16 199) "19. Bindings")
;; (find-tcltkpage (+ 16 199) "19.1 An overview of the bind command")
;; (find-tcltkpage (+ 16 201) "19.2 Event patterns")
;; (find-tcltkpage (+ 16 203) "19.3 Sequences of events")
;; (find-tcltkpage (+ 16 203) "19.4 Conflict resolution")
;; (find-tcltkpage (+ 16 204) "19.5 Substitutions in scripts")
;; (find-tcltkpage (+ 16 205) "19.6 When are events processed?")
;; (find-tcltkpage (+ 16 205) "19.7 Background errors: tkerror")
;; (find-tcltkpage (+ 16 206) "19.8 Other uses of bindings")
;; (find-tcltkpage (+ 16 207) "20. The Selection")
;; (find-tcltkpage (+ 16 207) "20.1 Selections, retrievals, and targets")
;; (find-tcltkpage (+ 16 209) "20.2 Locating and clearing the selection")
;; (find-tcltkpage (+ 16 210) "20.3 Supplying the selection with Tcl scripts")
;; (find-tcltkpage (+ 16 213) "21. The Input Focus")
;; (find-tcltkpage (+ 16 213) "21.1 Focus model: explicit vs. implicit")
;; (find-tcltkpage (+ 16 214) "21.2 Setting the input focus")
;; (find-tcltkpage (+ 16 215) "21.3 Clearing the focus")
;; (find-tcltkpage (+ 16 215) "21.4 The default focus")
;; (find-tcltkpage (+ 16 216) "21.5 Keyboard accelerators")
;; (find-tcltkpage (+ 16 217) "22. Window Managers")
;; (find-tcltkpage (+ 16 219) "22.1 Window sizes")
;; (find-tcltkpage (+ 16 220) "22.2 Gridded windows")
;; (find-tcltkpage (+ 16 222) "22.3 Window positions")
;; (find-tcltkpage (+ 16 222) "22.4 Window states")
;; (find-tcltkpage (+ 16 223) "22.5 Decorations")
;; (find-tcltkpage (+ 16 223) "22.6 Window manager protocols")
;; (find-tcltkpage (+ 16 224) "22.7 Special handling: transients, groups, and override-redirect")
;; (find-tcltkpage (+ 16 225) "22.8 Session management")
;; (find-tcltkpage (+ 16 225) "22.9 A warning about window managers")
;; (find-tcltkpage (+ 16 227) "23. The Send Command")
;; (find-tcltkpage (+ 16 227) "23.1 Basics")
;; (find-tcltkpage (+ 16 228) "23.2 Hypertools")
;; (find-tcltkpage (+ 16 229) "23.3 Application names")
;; (find-tcltkpage (+ 16 229) "23.4 Security issues")
;; (find-tcltkpage (+ 16 231) "24. Modal Interactions")
;; (find-tcltkpage (+ 16 231) "24.1 Grabs")
;; (find-tcltkpage (+ 16 233) "24.2 Keyboard handling during grabs")
;; (find-tcltkpage (+ 16 233) "24.3 Waiting: the tkwait command")
;; (find-tcltkpage (+ 16 237) "25. Odds and Ends")
;; (find-tcltkpage (+ 16 237) "25.1 Destroying windows")
;; (find-tcltkpage (+ 16 238) "25.2 Time delays")
;; (find-tcltkpage (+ 16 239) "25.3 The update command")
;; (find-tcltkpage (+ 16 240) "25.4 Information about windows")
;; (find-tcltkpage (+ 16 240) "25.5 The tk command: color models")
;; (find-tcltkpage (+ 16 241) "25.6 Variables managed by Tk")
;; (find-tcltkpage (+ 16 243) "26. Examples")
;; (find-tcltkpage (+ 16 243) "26.1 A procedure that generates dialog boxes")
;; (find-tcltkpage (+ 16 247) "26.2 A remote-control application")
;; (find-tcltkpage 275 "PART III: WRITING TCL APPLICATIONS IN C")
;; (find-tcltkpage (+ 20 257) "27. Philosophy")
;; (find-tcltkpage (+ 20 257) "27.1 C vs. Tcl: primitives")
;; (find-tcltkpage (+ 20 259) "27.2 Object names")
;; (find-tcltkpage (+ 20 260) "27.3 Commands: action-oriented vs. object-oriented")
;; (find-tcltkpage (+ 20 261) "27.4 Application prefixes")
;; (find-tcltkpage (+ 20 262) "27.5 Representing information")
;; (find-tcltkpage (+ 20 263) "28. Interpreters and Script Evaluation")
;; (find-tcltkpage (+ 20 263) "28.1 Interpreters")
;; (find-tcltkpage (+ 20 263) "28.2 A simple Tcl application")
;; (find-tcltkpage (+ 20 266) "28.3 Other evaluation procedures")
;; (find-tcltkpage (+ 20 266) "28.4 Deleting interpreters")
;; (find-tcltkpage (+ 20 269) "29. Creating New Tcl Commands")
;; (find-tcltkpage (+ 20 269) "29.1 Command procedures")
;; (find-tcltkpage (+ 20 271) "29.2 Registering commands")
;; (find-tcltkpage (+ 20 272) "29.3 The result protocol")
;; (find-tcltkpage (+ 20 273) "29.4 Procedures for managing the result")
;; (find-tcltkpage (+ 20 275) "29.5 ClientData and deletion callbacks")
;; (find-tcltkpage (+ 20 278) "29.6 Deleting commands")
;; (find-tcltkpage (+ 20 279) "30. Parsing")
;; (find-tcltkpage (+ 20 279) "30.1 Numbers and booleans")
;; (find-tcltkpage (+ 20 282) "30.2 Expression evaluation")
;; (find-tcltkpage (+ 20 283) "30.3 Manipulating lists")
;; (find-tcltkpage (+ 20 285) "31. Exceptions")
;; (find-tcltkpage (+ 20 285) "31.1 Completion codes.")
;; (find-tcltkpage (+ 20 288) "31.2 Augmenting the stack trace in errorInfo")
;; (find-tcltkpage (+ 20 290) "31.3 Setting errorCode")
;; (find-tcltkpage (+ 20 291) "32. Accessing Tcl Variables")
;; (find-tcltkpage (+ 20 291) "32.1 Naming variables")
;; (find-tcltkpage (+ 20 293) "32.2 Setting variable values")
;; (find-tcltkpage (+ 20 295) "32.3 Reading variables")
;; (find-tcltkpage (+ 20 296) "32.4 Unsetting variables")
;; (find-tcltkpage (+ 20 296) "32.5 Setting and unsetting variable traces")
;; (find-tcltkpage (+ 20 297) "32.6 Trace callbacks")
;; (find-tcltkpage (+ 20 299) "32.7 Whole-array traces")
;; (find-tcltkpage (+ 20 299) "32.8 Multiple traces")
;; (find-tcltkpage (+ 20 299) "32.9 Unset callbacks")
;; (find-tcltkpage (+ 20 300) "32.10 Non-existent variables")
;; (find-tcltkpage (+ 20 300) "32.11 Querying trace information")
;; (find-tcltkpage (+ 20 301) "33. Hash Tables")
;; (find-tcltkpage (+ 20 303) "33.1 Keys and values")
;; (find-tcltkpage (+ 20 303) "33.2 Creating and deleting hash tables")
;; (find-tcltkpage (+ 20 304) "33.3 Creating entries")
;; (find-tcltkpage (+ 20 305) "33.4 Finding existing entries")
;; (find-tcltkpage (+ 20 306) "33.5 Searching")
;; (find-tcltkpage (+ 20 307) "33.6 Deleting entries")
;; (find-tcltkpage (+ 20 307) "33.7 Statistics")
;; (find-tcltkpage (+ 20 309) "34. String Utilities")
;; (find-tcltkpage (+ 20 309) "34.1 Dynamic strings")
;; (find-tcltkpage (+ 20 312) "34.2 Command completeness")
;; (find-tcltkpage (+ 20 313) "34.3 String matching")
;; (find-tcltkpage (+ 20 315) "35. POSIX Utilities")
;; (find-tcltkpage (+ 20 315) "35.1 Tilde expansion")
;; (find-tcltkpage (+ 20 317) "35.2 Generating messages")
;; (find-tcltkpage (+ 20 318) "35.3 Creating subprocesses")
;; (find-tcltkpage (+ 20 319) "35.4 Background processes")
;; (find-tcltkpage 343 "PART IV: TK'S C INTERFACES")
;; (find-tcltkpage (+ 22 323) "36. Introduction")
;; (find-tcltkpage (+ 22 324) "36.1 What's in a widget?")
;; (find-tcltkpage (+ 22 325) "36.2 Widgets are event-driven")
;; (find-tcltkpage (+ 22 325) "36.3 Tk vs. Xlib")
;; (find-tcltkpage (+ 22 326) "36.4 Square: an example widget")
;; (find-tcltkpage (+ 22 328) "36.5 Design for re-usability")
;; (find-tcltkpage (+ 22 329) "37. Creating Windows")
;; (find-tcltkpage (+ 22 329) "37.1 Tk_Window structures")
;; (find-tcltkpage (+ 22 329) "37.2 Creating Tk_Windows")
;; (find-tcltkpage (+ 22 331) "37.3 Setting a window's class")
;; (find-tcltkpage (+ 22 332) "37.4 Deleting windows")
;; (find-tcltkpage (+ 22 332) "37.5 Basic operations on Tk_Windows")
;; (find-tcltkpage (+ 22 333) "37.6 Create procedures")
;; (find-tcltkpage (+ 22 336) "37.7 Delayed window creation")
;; (find-tcltkpage (+ 22 337) "38. Configuring Widgets")
;; (find-tcltkpage (+ 22 337) "38.1 Tk_ConfigureWidget")
;; (find-tcltkpage (+ 22 339) "38.1.1 Tk_ConfigSpec tables")
;; (find-tcltkpage (+ 22 341) "38.1.2 Invoking Tk_ConfigureWidget")
;; (find-tcltkpage (+ 22 342) "38.1.3 Errors")
;; (find-tcltkpage (+ 22 342) "38.1.4 Reconfiguring")
;; (find-tcltkpage (+ 22 342) "38.1.5 Tk_ConfigureInfo")
;; (find-tcltkpage (+ 22 343) "38.1.6 Tk_FreeOptions")
;; (find-tcltkpage (+ 22 343) "38.1.7 Other uses for configuration tables")
;; (find-tcltkpage (+ 22 343) "38.2 Resource caches")
;; (find-tcltkpage (+ 22 344) "38.2.1 Graphics contexts")
;; (find-tcltkpage (+ 22 345) "38.2.2 Other resources")
;; (find-tcltkpage (+ 22 346) "38.3 Tk_Uids")
;; (find-tcltkpage (+ 22 346) "38.4 Other translators")
;; (find-tcltkpage (+ 22 347) "38.5 Changing window attributes")
;; (find-tcltkpage (+ 22 348) "38.6 The square configure procedure")
;; (find-tcltkpage (+ 22 349) "38.7 The square widget command procedure")
;; (find-tcltkpage (+ 22 353) "39. Events")
;; (find-tcltkpage (+ 22 353) "39.1 X events")
;; (find-tcltkpage (+ 22 357) "39.2 File events")
;; (find-tcltkpage (+ 22 359) "39.3 Timer events")
;; (find-tcltkpage (+ 22 360) "39.4 Idle callbacks")
;; (find-tcltkpage (+ 22 361) "39.5 Generic event handlers")
;; (find-tcltkpage (+ 22 362) "39.6 Invoking the event dispatcher")
;; (find-tcltkpage (+ 22 365) "40. Displaying Widgets")
;; (find-tcltkpage (+ 22 365) "40.1 Delayed redisplay")
;; (find-tcltkpage (+ 22 367) "40.2 Double-buffering with pixmaps")
;; (find-tcltkpage (+ 22 367) "40.3 Drawing procedures")
;; (find-tcltkpage (+ 22 371) "41. Destroying Widgets")
;; (find-tcltkpage (+ 22 371) "41.1 Basics")
;; (find-tcltkpage (+ 22 372) "41.2 Delayed cleanup")
;; (find-tcltkpage (+ 22 377) "42. Managing the Selection")
;; (find-tcltkpage (+ 22 377) "42.1 Selection handlers")
;; (find-tcltkpage (+ 22 380) "42.2 Claiming the selection")
;; (find-tcltkpage (+ 22 381) "42.3 Retrieving the selection")
;; (find-tcltkpage (+ 22 383) "43. Geometry Management")
;; (find-tcltkpage (+ 22 383) "43.1 Requesting a size for a widget")
;; (find-tcltkpage (+ 22 385) "43.2 Internal borders")
;; (find-tcltkpage (+ 22 386) "43.3 Grids")
;; (find-tcltkpage (+ 22 387) "43.4 Geometry managers")
;; (find-tcltkpage (+ 22 388) "43.5 Claiming ownership")
;; (find-tcltkpage (+ 22 388) "43.6 Retrieving geometry information")
;; (find-tcltkpage (+ 22 389) "43.7 Mapping and setting geometry")
;; (find-tcltktext "")
;; (find-tcltktext "")
;; «o_keefe» (to ".o_keefe")
;; (find-books "__comp/__comp.el" "o_keefe")
;; https://doi.org/10.1016/j.entcs.2003.12.014
;; Greg O'Keefe: "Towards a Readable Formalisation of Category Theory" (2004)
(code-pdf "okeefereadable" "~/books/__comp/o_keefe__towards_a_readable_formalisation_of_category_theory.pdf")
(code-pdftotext "okeefereadable" "~/books/__comp/o_keefe__towards_a_readable_formalisation_of_category_theory.pdf" 212)
;; (find-okeefereadablepage)
;; (find-okeefereadablepage 1 "Contents")
;; (find-okeefereadablepage (+ 1 189) "Index")
;; (find-okeefereadabletext "")
;; «oliveira» (to ".oliveira")
;; (find-books "__comp/__comp.el" "oliveira")
;; https://fabianooliveira.ime.uerj.br/lecture-notes
(code-pdf-page "oliveiradpcc" "~/books/__comp/oliveira_2021_desenvolvendo_programas_com_correcao.pdf")
(code-pdf-text "oliveiradpcc" "~/books/__comp/oliveira_2021_desenvolvendo_programas_com_correcao.pdf" 1)
;; (find-oliveiradpccpage)
;; (find-oliveiradpccpage 1 "Contents")
;; (find-oliveiradpccpage (+ 1 189) "Index")
;; (find-oliveiradpcctext "")
;; (find-fline "~/fsoliveira/README")
;; http://anggtwu.net/fsoliveira/
;; http://anggtwu.net/fsoliveira/README.html
;; http://anggtwu.net/fsoliveira/dpcc.pdf
(code-pdf-page "fsodpcc" "~/fsoliveira/dpcc.pdf")
(code-pdf-text "fsodpcc" "~/fsoliveira/dpcc.pdf")
;; (find-fsodpccpage)
;; (find-fsodpcctext)
;; «paulson» (to ".paulson")
;; http://gigapedia.com/items/28928/ml-for-the-working-programmer
(code-djvu "mlwp" "~/books/__comp/paulson__ml_for_the_working_programmer.djvu")
;; (find-mlwppage 3 "Contents")
;; (find-mlwppage (+ 15 469) "Index")
;; «perrone» (to ".perrone")
;; (find-books "__comp/__comp.el" "perrone")
;; http://paoloperrone.org/phdthesis.pdf
(code-pdf-page "perronephd" "$S/http/paoloperrone.org/phdthesis.pdf")
(code-pdf-text "perronephd" "$S/http/paoloperrone.org/phdthesis.pdf")
;; (find-perronephdpage)
;; (find-perronephdtext)
;; (find-perronephdpage 9 "Contents")
;; (find-perronephdtext 9 "Contents")
;; «peyton-jones» (to ".peyton-jones")
;; (find-books "__comp/__comp.el" "peyton-jones")
;; https://www.microsoft.com/en-us/research/people/simonpj/
;; https://www.microsoft.com/en-us/research/publication/the-implementation-of-functional-programming-languages/
;; https://www.microsoft.com/en-us/research/wp-content/uploads/1987/01/slpj-book-1987-small.pdf
;; (find-fline "$S/https/www.microsoft.com/en-us/research/wp-content/uploads/1987/01/")
(code-xpdf "impfpl" "$S/https/www.microsoft.com/en-us/research/wp-content/uploads/1987/01/slpj-book-1987-small.pdf")
;; (find-impfplpage)
;; (find-impfplpage 4 "Contents")
;; (find-impfplpage (+ 13 1) "1. Introduction")
;; (find-impfplpage (+ 13 439) "Index")
;; https://www.microsoft.com/en-us/research/publication/a-quick-look-at-impredicativity/
;; https://www.microsoft.com/en-us/research/uploads/prod/2020/01/quick-look-icfp20.pdf
;; (find-fline "$S/https/www.microsoft.com/en-us/research/uploads/prod/2020/01/")
(code-pdf-page "spjquicklooki" "$S/https/www.microsoft.com/en-us/research/uploads/prod/2020/01/quick-look-icfp20.pdf")
(code-pdf-text "spjquicklooki" "$S/https/www.microsoft.com/en-us/research/uploads/prod/2020/01/quick-look-icfp20.pdf")
;; (find-spjquicklookipage)
;; (find-spjquicklookitext)
;; https://www.microsoft.com/en-us/research/academic-program/write-great-research-paper/
;; https://www.microsoft.com/en-us/research/academic-program/write-great-research-paper/#!other-resources
;; https://www.microsoft.com/en-us/research/wp-content/uploads/2016/07/How-to-write-a-great-research-paper.pdf
;; (find-fline "$S/https/www.microsoft.com/en-us/research/wp-content/uploads/2016/07/")
;; (find-pdf-page "$S/https/www.microsoft.com/en-us/research/wp-content/uploads/2016/07/How-to-write-a-great-research-paper.pdf")
;; (find-pdf-text "$S/https/www.microsoft.com/en-us/research/wp-content/uploads/2016/07/How-to-write-a-great-research-paper.pdf")
;; «pierce» (to ".pierce")
;; (find-books "__comp/__comp.el" "pierce")
;; https://www.cis.upenn.edu/~bcpierce/tapl/
(code-pdf-page "tapl" "~/books/__comp/pierce__types_and_programming_languages.pdf")
(code-pdf-text "tapl" "~/books/__comp/pierce__types_and_programming_languages.pdf" 22)
;; (find-taplpage)
;; (find-taplpage (+ 22 1) "1 Introduction")
;; (find-taplpage (+ 22 1) "1.1 Types in Computer Science")
;; (find-taplpage (+ 22 4) "1.2 What Type Systems Are Good For")
;; (find-taplpage (+ 22 9) "1.3 Type Systems and Language Design")
;; (find-taplpage (+ 22 10) "1.4 Capsule History")
;; (find-taplpage (+ 22 12) "1.5 Related Reading")
;; (find-taplpage (+ 22 15) "2 Mathematical Preliminaries")
;; (find-taplpage (+ 22 15) "2.1 Sets, Relations, and Functions")
;; (find-taplpage (+ 22 16) "2.2 Ordered Sets")
;; (find-taplpage (+ 22 18) "2.3 Sequences")
;; (find-taplpage (+ 22 19) "2.4 Induction")
;; (find-taplpage (+ 22 20) "2.5 Background Reading")
;; (find-taplpage (+ 22 21) "I Untyped Systems")
;; (find-taplpage (+ 22 23) "3 Untyped Arithmetic Expressions")
;; (find-taplpage (+ 22 23) "3.1 Introduction")
;; (find-taplpage (+ 22 26) "3.2 Syntax")
;; (find-taplpage (+ 22 29) "3.3 Induction on Terms")
;; (find-taplpage (+ 22 32) "3.4 Semantic Styles")
;; (find-taplpage (+ 22 34) "3.5 Evaluation")
;; (find-taplpage (+ 22 43) "3.6 Notes")
;; (find-taplpage (+ 22 45) "4 An ML Implementation of Arithmetic Expressions")
;; (find-taplpage (+ 22 46) "4.1 Syntax")
;; (find-taplpage (+ 22 47) "4.2 Evaluation")
;; (find-taplpage (+ 22 49) "4.3 The Rest of the Story")
;; (find-taplpage (+ 22 51) "5 The Untyped Lambda-Calculus")
;; (find-taplpage (+ 22 52) "5.1 Basics")
;; (find-taplpage (+ 22 58) "5.2 Programming in the Lambda-Calculus")
;; (find-taplpage (+ 22 68) "5.3 Formalities")
;; (find-taplpage (+ 22 73) "5.4 Notes")
;; (find-taplpage (+ 22 75) "6 Nameless Representation of Terms")
;; (find-taplpage (+ 22 76) "6.1 Terms and Contexts")
;; (find-taplpage (+ 22 78) "6.2 Shifting and Substitution")
;; (find-taplpage (+ 22 80) "6.3 Evaluation")
;; (find-taplpage (+ 22 83) "7 An ML Implementation of the Lambda-Calculus")
;; (find-taplpage (+ 22 83) "7.1 Terms and Contexts")
;; (find-taplpage (+ 22 85) "7.2 Shifting and Substitution")
;; (find-taplpage (+ 22 87) "7.3 Evaluation")
;; (find-taplpage (+ 22 88) "7.4 Notes")
;; (find-taplpage (+ 22 89) "II Simple Types")
;; (find-taplpage (+ 22 91) "8 Typed Arithmetic Expressions")
;; (find-taplpage (+ 22 91) "8.1 Types")
;; (find-taplpage (+ 22 92) "8.2 The Typing Relation")
;; (find-taplpage (+ 22 95) "8.3 Safety = Progress + Preservation")
;; (find-taplpage (+ 22 99) "9 Simply Typed Lambda-Calculus")
;; (find-taplpage (+ 22 99) "9.1 Function Types")
;; (find-taplpage (+ 22 100) "9.2 The Typing Relation")
;; (find-taplpage (+ 22 104) "9.3 Properties of Typing")
;; (find-taplpage (+ 22 108) "9.4 The Curry-Howard Correspondence")
;; (find-taplpage (+ 22 109) "9.5 Erasure and Typability")
;; (find-taplpage (+ 22 111) "9.6 Curry-Style vs. Church-Style")
;; (find-taplpage (+ 22 111) "9.7 Notes")
;; (find-taplpage (+ 22 113) "10 An ML Implementation of Simple Types")
;; (find-taplpage (+ 22 113) "10.1 Contexts")
;; (find-taplpage (+ 22 115) "10.2 Terms and Types")
;; (find-taplpage (+ 22 115) "10.3 Typechecking")
;; (find-taplpage (+ 22 117) "11 Simple Extensions")
;; (find-taplpage (+ 22 117) "11.1 Base Types")
;; (find-taplpage (+ 22 118) "11.2 The Unit Type")
;; (find-taplpage (+ 22 119) "11.3 Derived Forms: Sequencing and Wildcards")
;; (find-taplpage (+ 22 121) "11.4 Ascription")
;; (find-taplpage (+ 22 124) "11.5 Let Bindings")
;; (find-taplpage (+ 22 126) "11.6 Pairs")
;; (find-taplpage (+ 22 128) "11.7 Tuples")
;; (find-taplpage (+ 22 129) "11.8 Records")
;; (find-taplpage (+ 22 132) "11.9 Sums")
;; (find-taplpage (+ 22 136) "11.10 Variants")
;; (find-taplpage (+ 22 142) "11.11 General Recursion")
;; (find-taplpage (+ 22 146) "11.12 Lists")
;; (find-taplpage (+ 22 149) "12 Normalization")
;; (find-taplpage (+ 22 149) "12.1 Normalization for Simple Types")
;; (find-taplpage (+ 22 152) "12.2 Notes")
;; (find-taplpage (+ 22 153) "13 References")
;; (find-taplpage (+ 22 153) "13.1 Introduction")
;; (find-taplpage (+ 22 159) "13.2 Typing")
;; (find-taplpage (+ 22 159) "13.3 Evaluation")
;; (find-taplpage (+ 22 162) "13.4 Store Typings")
;; (find-taplpage (+ 22 165) "13.5 Safety")
;; (find-taplpage (+ 22 170) "13.6 Notes")
;; (find-taplpage (+ 22 171) "14 Exceptions")
;; (find-taplpage (+ 22 172) "14.1 Raising Exceptions")
;; (find-taplpage (+ 22 173) "14.2 Handling Exceptions")
;; (find-taplpage (+ 22 175) "14.3 Exceptions Carrying Values")
;; (find-taplpage (+ 22 179) "III Subtyping")
;; (find-taplpage (+ 22 181) "15 Subtyping")
;; (find-taplpage (+ 22 181) "15.1 Subsumption")
;; (find-taplpage (+ 22 182) "15.2 The Subtype Relation")
;; (find-taplpage (+ 22 188) "15.3 Properties of Subtyping and Typing")
;; (find-taplpage (+ 22 191) "15.4 The Top and Bottom Types")
;; (find-taplpage (+ 22 193) "15.5 Subtyping and Other Features")
;; (find-taplpage (+ 22 200) "15.6 Coercion Semantics for Subtyping")
;; (find-taplpage (+ 22 206) "15.7 Intersection and Union Types")
;; (find-taplpage (+ 22 207) "15.8 Notes")
;; (find-taplpage (+ 22 209) "16 Metatheory of Subtyping")
;; (find-taplpage (+ 22 210) "16.1 Algorithmic Subtyping")
;; (find-taplpage (+ 22 213) "16.2 Algorithmic Typing")
;; (find-taplpage (+ 22 218) "16.3 Joins and Meets")
;; (find-taplpage (+ 22 220) "16.4 Algorithmic Typing and the Bottom Type")
;; (find-taplpage (+ 22 221) "17 An ML Implementation of Subtyping")
;; (find-taplpage (+ 22 221) "17.1 Syntax")
;; (find-taplpage (+ 22 221) "17.2 Subtyping")
;; (find-taplpage (+ 22 222) "17.3 Typing")
;; (find-taplpage (+ 22 225) "18 Case Study: Imperative Objects")
;; (find-taplpage (+ 22 225) "18.1 What Is Object-Oriented Programming?")
;; (find-taplpage (+ 22 228) "18.2 Objects")
;; (find-taplpage (+ 22 229) "18.3 Object Generators")
;; (find-taplpage (+ 22 229) "18.4 Subtyping")
;; (find-taplpage (+ 22 230) "18.5 Grouping Instance Variables")
;; (find-taplpage (+ 22 231) "18.6 Simple Classes")
;; (find-taplpage (+ 22 233) "18.7 Adding Instance Variables")
;; (find-taplpage (+ 22 234) "18.8 Calling Superclass Methods")
;; (find-taplpage (+ 22 234) "18.9 Classes with Self")
;; (find-taplpage (+ 22 235) "18.10 Open Recursion through Self")
;; (find-taplpage (+ 22 237) "18.11 Open Recursion and Evaluation Order")
;; (find-taplpage (+ 22 241) "18.12 A More Efficient Implementation")
;; (find-taplpage (+ 22 244) "18.13 Recap")
;; (find-taplpage (+ 22 245) "18.14 Notes")
;; (find-taplpage (+ 22 247) "19 Case Study: Featherweight Java")
;; (find-taplpage (+ 22 247) "19.1 Introduction")
;; (find-taplpage (+ 22 249) "19.2 Overview")
;; (find-taplpage (+ 22 251) "19.3 Nominal and Structural Type Systems")
;; (find-taplpage (+ 22 254) "19.4 Definitions")
;; (find-taplpage (+ 22 261) "19.5 Properties")
;; (find-taplpage (+ 22 262) "19.6 Encodings vs. Primitive Objects")
;; (find-taplpage (+ 22 263) "19.7 Notes")
;; (find-taplpage (+ 22 265) "IV Recursive Types")
;; (find-taplpage (+ 22 267) "20 Recursive Types")
;; (find-taplpage (+ 22 268) "20.1 Examples")
;; (find-taplpage (+ 22 275) "20.2 Formalities")
;; (find-taplpage (+ 22 279) "20.3 Subtyping")
;; (find-taplpage (+ 22 279) "20.4 Notes")
;; (find-taplpage (+ 22 281) "21 Metatheory of Recursive Types")
;; (find-taplpage (+ 22 282) "21.1 Induction and Coinduction")
;; (find-taplpage (+ 22 284) "21.2 Finite and Infinite Types")
;; (find-taplpage (+ 22 286) "21.3 Subtyping")
;; (find-taplpage (+ 22 288) "21.4 A Digression on Transitivity")
;; (find-taplpage (+ 22 290) "21.5 Membership Checking")
;; (find-taplpage (+ 22 295) "21.6 More Efficient Algorithms")
;; (find-taplpage (+ 22 298) "21.7 Regular Trees")
;; (find-taplpage (+ 22 299) "21.8 µ-Types")
;; (find-taplpage (+ 22 304) "21.9 Counting Subexpressions")
;; (find-taplpage (+ 22 309) "21.10 Digression: An Exponential Algorithm")
;; (find-taplpage (+ 22 311) "21.11 Subtyping Iso-Recursive Types")
;; (find-taplpage (+ 22 312) "21.12 Notes")
;; (find-taplpage (+ 22 315) "V Polymorphism")
;; (find-taplpage (+ 22 317) "22 Type Reconstruction")
;; (find-tapltext (+ 22 317) "22 Type Reconstruction")
;; (find-taplpage (+ 22 317) "22.1 Type Variables and Substitutions")
;; (find-taplpage (+ 22 319) "22.2 Two Views of Type Variables")
;; (find-taplpage (+ 22 321) "22.3 Constraint-Based Typing")
;; (find-taplpage (+ 22 326) "22.4 Unification")
;; (find-taplpage (+ 22 329) "22.5 Principal Types")
;; (find-taplpage (+ 22 330) "22.6 Implicit Type Annotations")
;; (find-taplpage (+ 22 331) "22.7 Let-Polymorphism")
;; (find-taplpage (+ 22 336) "22.8 Notes")
;; (find-taplpage (+ 22 339) "23 Universal Types")
;; (find-taplpage (+ 22 339) "23.1 Motivation")
;; (find-taplpage (+ 22 340) "23.2 Varieties of Polymorphism")
;; (find-taplpage (+ 22 341) "23.3 System F")
;; (find-taplpage (+ 22 344) "23.4 Examples")
;; (find-taplpage (+ 22 353) "23.5 Basic Properties")
;; (find-taplpage (+ 22 354) "23.6 Erasure, Typability, and Type Reconstruction")
;; (find-taplpage (+ 22 357) "23.7 Erasure and Evaluation Order")
;; (find-taplpage (+ 22 358) "23.8 Fragments of System F")
;; (find-taplpage (+ 22 359) "23.9 Parametricity")
;; (find-taplpage (+ 22 360) "23.10 Impredicativity")
;; (find-taplpage (+ 22 361) "23.11 Notes")
;; (find-taplpage (+ 22 363) "24 Existential Types")
;; (find-taplpage (+ 22 363) "24.1 Motivation")
;; (find-taplpage (+ 22 368) "24.2 Data Abstraction with Existentials")
;; (find-taplpage (+ 22 377) "24.3 Encoding Existentials")
;; (find-taplpage (+ 22 379) "24.4 Notes")
;; (find-taplpage (+ 22 381) "25 An ML Implementation of System F")
;; (find-taplpage (+ 22 381) "25.1 Nameless Representation of Types")
;; (find-taplpage (+ 22 382) "25.2 Type Shifting and Substitution")
;; (find-taplpage (+ 22 383) "25.3 Terms")
;; (find-taplpage (+ 22 385) "25.4 Evaluation")
;; (find-taplpage (+ 22 386) "25.5 Typing")
;; (find-taplpage (+ 22 389) "26 Bounded Quantification")
;; (find-taplpage (+ 22 389) "26.1 Motivation")
;; (find-taplpage (+ 22 391) "26.2 Definitions")
;; (find-taplpage (+ 22 396) "26.3 Examples")
;; (find-taplpage (+ 22 400) "26.4 Safety")
;; (find-taplpage (+ 22 406) "26.5 Bounded Existential Types")
;; (find-taplpage (+ 22 408) "26.6 Notes")
;; (find-taplpage (+ 22 411) "27 Case Study: Imperative Objects, Redux")
;; (find-taplpage (+ 22 417) "28 Metatheory of Bounded Quantification")
;; (find-taplpage (+ 22 417) "28.1 Exposure")
;; (find-taplpage (+ 22 418) "28.2 Minimal Typing")
;; (find-taplpage (+ 22 421) "28.3 Subtyping in Kernel F<:")
;; (find-taplpage (+ 22 424) "28.4 Subtyping in Full F<:")
;; (find-taplpage (+ 22 427) "28.5 Undecidability of Full F<:")
;; (find-taplpage (+ 22 432) "28.6 Joins and Meets")
;; (find-taplpage (+ 22 435) "28.7 Bounded Existentials")
;; (find-taplpage (+ 22 436) "28.8 Bounded Quantification and the Bottom Type")
;; (find-taplpage (+ 22 437) "VI Higher-Order Systems")
;; (find-taplpage (+ 22 439) "29 Type Operators and Kinding")
;; (find-taplpage (+ 22 440) "29.1 Intuitions")
;; (find-taplpage (+ 22 445) "29.2 Definitions")
;; (find-taplpage (+ 22 449) "30 Higher-Order Polymorphism")
;; (find-taplpage (+ 22 449) "30.1 Definitions")
;; (find-taplpage (+ 22 450) "30.2 Example")
;; (find-taplpage (+ 22 453) "30.3 Properties")
;; (find-taplpage (+ 22 461) "30.4 Fragments of F")
;; (find-taplpage (+ 22 462) "30.5 Going Further: Dependent Types")
;; (find-taplpage (+ 22 467) "31 Higher-Order Subtyping")
;; (find-taplpage (+ 22 467) "31.1 Intuitions")
;; (find-taplpage (+ 22 469) "31.2 Definitions")
;; (find-taplpage (+ 22 472) "31.3 Properties")
;; (find-taplpage (+ 22 472) "31.4 Notes")
;; (find-taplpage (+ 22 475) "32 Case Study: Purely Functional Objects")
;; (find-taplpage (+ 22 475) "32.1 Simple Objects")
;; (find-taplpage (+ 22 476) "32.2 Subtyping")
;; (find-taplpage (+ 22 477) "32.3 Bounded Quantification")
;; (find-taplpage (+ 22 479) "32.4 Interface Types")
;; (find-taplpage (+ 22 480) "32.5 Sending Messages to Objects")
;; (find-taplpage (+ 22 481) "32.6 Simple Classes")
;; (find-taplpage (+ 22 482) "32.7 Polymorphic Update")
;; (find-taplpage (+ 22 485) "32.8 Adding Instance Variables")
;; (find-taplpage (+ 22 486) "32.9 Classes with "Self"")
;; (find-taplpage (+ 22 488) "32.10 Notes")
;; (find-taplpage (+ 22 491) "Appendices")
;; (find-taplpage (+ 22 493) "A Solutions to Selected Exercises")
;; (find-taplpage (+ 22 565) "B Notational Conventions")
;; (find-taplpage (+ 22 565) "B.1 Metavariable Names")
;; (find-taplpage (+ 22 565) "B.2 Rule Naming Conventions")
;; (find-taplpage (+ 22 566) "B.3 Naming and Subscripting Conventions")
;; (find-taplpage (+ 22 567) "References")
;; (find-taplpage (+ 22 605) "Index")
;; (find-tapltext (+ 22 605) "Index")
;; (find-taplpage (+ 22 621) " type reconstruction")
;; (find-tapltext (+ 22 621) " type reconstruction")
;; (find-tapltext "")
;; «pierce-atitapl» (to ".pierce-atitapl")
;; (find-books "__comp/__comp.el" "pierce-atitapl")
(code-pdf-page "atitapl" "~/books/__comp/pierce__advanced_topics_in_types_and_programming_languages.pdf")
(code-pdf-text "atitapl" "~/books/__comp/pierce__advanced_topics_in_types_and_programming_languages.pdf" 15)
;; (find-atitaplpage)
;; (find-atitaplpage 6 "Contents")
;; (find-atitapltext 6 "Contents")
;; (find-atitaplpage (+ 15 1) "I Precise Type Analyses")
;; (find-atitaplpage (+ 15 3) "1 Substructural Type Systems")
;; (find-atitaplpage (+ 15 4) "1.1 Structural Properties")
;; (find-atitaplpage (+ 15 6) "1.2 A Linear Type System")
;; (find-atitaplpage (+ 15 17) "1.3 Extensions and Variations")
;; (find-atitaplpage (+ 15 30) "1.4 An Ordered Type System")
;; (find-atitaplpage (+ 15 36) "1.5 Further Applications")
;; (find-atitaplpage (+ 15 40) "1.6 Notes")
;; (find-atitaplpage (+ 15 45) "2 Dependent Types")
;; (find-atitaplpage (+ 15 45) "2.1 Motivations")
;; (find-atitaplpage (+ 15 50) "2.2 Pure First-Order Dependent Types")
;; (find-atitaplpage (+ 15 54) "2.3 Properties")
;; (find-atitaplpage (+ 15 56) "2.4 Algorithmic Typing and Equality")
;; (find-atitaplpage (+ 15 61) "2.5 Dependent Sum Types")
;; (find-atitaplpage (+ 15 64) "2.6 The Calculus of Constructions")
;; (find-atitaplpage (+ 15 71) "2.7 Relating Abstractions: Pure Type Systems")
;; (find-atitaplpage (+ 15 74) "2.8 Programming with Dependent Types")
;; (find-atitaplpage (+ 15 83) "2.9 Implementation of Dependent Types")
;; (find-atitaplpage (+ 15 86) "2.10 Further Reading")
;; (find-atitaplpage (+ 15 87) "3 Effect Types and Region-Based Memory Management")
;; (find-atitaplpage (+ 15 141) "4 Typed Assembly Language")
;; (find-atitaplpage (+ 15 177) "5 Proof-Carrying Code")
;; (find-atitaplpage (+ 15 223) "6 Logical Relations and a Case Study in Equivalence Checking")
;; (find-atitaplpage (+ 15 245) "7 Typed Operational Reasoning")
;; (find-atitaplpage (+ 15 293) "8 Design Considerations for ML-Style Module Systems")
;; (find-atitaplpage (+ 15 347) "9 Type Definitions")
;; (find-atitaplpage (+ 15 351) "9.1 Definitions in the Typing Context")
;; (find-atitaplpage (+ 15 358) "9.2 Definitions in Module Interfaces")
;; (find-atitaplpage (+ 15 367) "9.3 Singleton Kinds")
;; (find-atitaplpage (+ 15 384) "9.4 Notes")
;; (find-atitaplpage (+ 15 389) "10 The Essence of ML Type Inference")
;; (find-atitaplpage (+ 15 389) "10.1 What Is ML?")
;; (find-atitaplpage (+ 15 407) "10.2 Constraints")
;; (find-atitaplpage (+ 15 422) "10.3 HM(X)")
;; (find-atitaplpage (+ 15 429) "10.4 Constraint Generation")
;; (find-atitaplpage (+ 15 434) "10.5 Type Soundness")
;; (find-atitaplpage (+ 15 438) "10.6 Constraint Solving")
;; (find-atitaplpage (+ 15 451) "10.7 From ML-the-Calculus to ML-the-Language")
;; (find-atitaplpage (+ 15 460) "10.8 Rows")
;; (find-atitaplpage (+ 15 491) "A Solutions to Selected Exercises")
;; (find-atitaplpage (+ 15 535) "References")
;; (find-atitaplpage (+ 15 567) "Index")
;; (find-atitapltext "")
;; «plotkin» (to ".plotkin")
;; http://homepages.inf.ed.ac.uk/gdp/
;; http://homepages.inf.ed.ac.uk/gdp/publications/
;; http://homepages.inf.ed.ac.uk/gdp/publications/Framework_Def_Log.pdf
(code-pdf-page "plotkinLF" "$S/http/homepages.inf.ed.ac.uk/gdp/publications/Framework_Def_Log.pdf")
(code-pdf-text "plotkinLF" "$S/http/homepages.inf.ed.ac.uk/gdp/publications/Framework_Def_Log.pdf")
;; (find-plotkinLFpage)
;; (find-plotkinLFtext)
;; «plotkin-partdiff» (to ".plotkin-partdiff")
;; (find-books "__comp/__comp.el" "plotkin-partdiff")
;; Gordon Plotkin: A complete axiomatisation of partial differentiation
;; http://math.ucr.edu/home/baez/ACT@UCR/index.html#plotkin
;; http://math.ucr.edu/home/baez/mathematical/ACTUCR/Plotkin_Partial_Differentiation.pdf
;; http://math.ucr.edu/home/baez/mathematical/ACTUCR/Plotkin_Partial_Differentiation.mp4
;; https://www.youtube.com/watch?v=j_w6GNUIQDo&w=560&h=315
(code-pdf-page "plotkincapd" "$S/http/math.ucr.edu/home/baez/mathematical/ACTUCR/Plotkin_Partial_Differentiation.pdf")
(code-pdf-text "plotkincapd" "$S/http/math.ucr.edu/home/baez/mathematical/ACTUCR/Plotkin_Partial_Differentiation.pdf")
;; (find-plotkincapdpage)
;; (find-plotkincapdtext)
;;
;; Fiore-Plotkin-Turi: Abstract Syntax and Variable Binding
;; http://homepages.inf.ed.ac.uk/gdp/publications/Abstract_Syn.pdf
;;
;; Mitchell/Plotkin: "Abstract Types Have Existential Type" (1988)
;; http://homepages.inf.ed.ac.uk/gdp/publications/Abstract_existential.pdf
(code-pdf-page "plotkinathet" "$S/http/homepages.inf.ed.ac.uk/gdp/publications/Abstract_existential.pdf")
(code-pdf-text "plotkinathet" "$S/http/homepages.inf.ed.ac.uk/gdp/publications/Abstract_existential.pdf")
;; (find-plotkinathetpage)
;; (find-plotkinathettext)
;; «raymond» (to ".raymond")
;; (find-books "__comp/__comp.el" "raymond")
(code-pdf-page "artofunixp" "~/books/__comp/raymond__the_art_of_unix_programming.pdf")
(code-pdf-text "artofunixp" "~/books/__comp/raymond__the_art_of_unix_programming.pdf" 33)
;; (find-artofunixppage)
;; (find-artofunixppage 10 "Contents")
;; (find-artofunixptext 10 "Contents")
;; (find-artofunixppage (+ 33 11) "a sign of peak efficiency")
;; (find-artofunixptext (+ 33 11) "a sign of peak efficiency")
;; (find-artofunixppage (+ 33 183) "8 Minilanguages: Finding a Notation That Sings")
;; (find-artofunixppage (+ 33 185) "8.1 Understanding the Taxonomy of Languages")
;; (find-artofunixppage (+ 33 187) "8.2 Applying Minilanguages")
;; (find-artofunixppage (+ 33 187) "8.2.1 Case Study: sng")
;; (find-artofunixppage (+ 33 188) "8.2.2 Case Study: Regular Expressions")
;; (find-artofunixppage (+ 33 191) "8.2.3 Case Study: Glade")
;; (find-artofunixppage (+ 33 193) "8.2.4 Case Study: m4")
;; (find-artofunixppage (+ 33 194) "8.2.5 Case Study: XSLT")
;; (find-artofunixppage (+ 33 195) "8.2.6 Case Study: The Documenter's Workbench Tools")
;; (find-artofunixppage (+ 33 199) "8.2.7 Case Study: fetchmail Run-Control Syntax")
;; (find-artofunixppage (+ 33 200) "8.2.8 Case Study: awk")
;; (find-artofunixppage (+ 33 202) "8.2.9 Case Study: PostScript")
;; (find-artofunixppage (+ 33 203) "8.2.10 Case Study: bc and dc")
;; (find-artofunixppage (+ 33 205) "8.2.11 Case Study: Emacs Lisp")
;; (find-artofunixppage (+ 33 205) "8.2.12 Case Study: JavaScript")
;; (find-artofunixppage (+ 33 206) "8.3 Designing Minilanguages")
;; (find-artofunixppage (+ 33 207) "8.3.1 Choosing the Right Complexity Level")
;; (find-artofunixppage (+ 33 209) "8.3.2 Extending and Embedding Languages")
;; (find-artofunixppage (+ 33 210) "8.3.3 Writing a Custom Grammar")
;; (find-artofunixppage (+ 33 210) "8.3.4 Macros--Beware!")
;; (find-artofunixppage (+ 33 212) "8.3.5 Language or Application Protocol?")
;; (find-artofunixppage (+ 33 3) "Index")
;; (find-artofunixptext "")
;; «reynolds» (to ".reynolds")
;; (find-books "__comp/__comp.el" "reynolds")
(code-pdf-page "reynoldstpl" "~/books/__comp/reynolds__theories_of_programming_languages.pdf")
(code-pdf-text "reynoldstpl" "~/books/__comp/reynolds__theories_of_programming_languages.pdf" 13)
;; (find-reynoldstplpage)
;; (find-reynoldstplpage 6 "Contents")
;; (find-reynoldstplpage (+ 1 189) "Index")
;; (find-reynoldstpltext "")
;; (find-reynoldstplpage (+ 13 0) "Preface")
;; (find-reynoldstplpage (+ 13 0) "1 Predicate Logic")
;; (find-reynoldstplpage (+ 13 0) "1.1 Abstract Syntax")
;; (find-reynoldstplpage (+ 13 0) "1.2 Denotational Semantics of Predicate Logic")
;; (find-reynoldstplpage (+ 13 0) "1.3 Validity and Inference")
;; (find-reynoldstplpage (+ 13 0) "1.4 Binding and Substitution")
;; (find-reynoldstplpage (+ 13 0) "2 The Simple Imperative Language")
;; (find-reynoldstplpage (+ 13 0) "2.1 Syntax")
;; (find-reynoldstplpage (+ 13 0) "2.2 Denotational Semantics")
;; (find-reynoldstplpage (+ 13 0) "2.3 Domains and Continuous Functions")
;; (find-reynoldstplpage (+ 13 0) "2.4 The Least Fixed-Point Theorem")
;; (find-reynoldstplpage (+ 13 0) "2.5 Variable Declarations and Substitution")
;; (find-reynoldstplpage (+ 13 0) "2.6 Syntactic Sugar: The for Command")
;; (find-reynoldstplpage (+ 13 0) "2.7 Arithmetic Errors")
;; (find-reynoldstplpage (+ 13 0) "2.8 Soundness and Full Abstraction")
;; (find-reynoldstplpage (+ 13 0) "3 Program Specifications and Their Proofs")
;; (find-reynoldstplpage (+ 13 0) "3.1 Syntax and Semantics of Specifications")
;; (find-reynoldstplpage (+ 13 0) "3.2 Inference Rules")
;; (find-reynoldstplpage (+ 13 0) "3.3 Rules for Assignment and Sequential Composition")
;; (find-reynoldstplpage (+ 13 0) "3.4 Rules for while Commands")
;; (find-reynoldstplpage (+ 13 0) "3.5 Further Rules")
;; (find-reynoldstplpage (+ 13 0) "3.6 Computing Fibonacci Numbers")
;; (find-reynoldstplpage (+ 13 0) "3.7 Fast Exponentiation")
;; (find-reynoldstplpage (+ 13 0) "3.8 Complications and Limitations")
;; (find-reynoldstplpage (+ 13 0) "4 Arrays")
;; (find-reynoldstplpage (+ 13 0) "4.1 Abstract Syntax")
;; (find-reynoldstplpage (+ 13 0) "4.2 Denotational Semantics")
;; (find-reynoldstplpage (+ 13 0) "4.3 Binary Search")
;; (find-reynoldstplpage (+ 13 0) "4.4 Inference Rules for Arrays")
;; (find-reynoldstplpage (+ 13 93) "4.5 Higher-Order Assertions About Arrays")
;; (find-reynoldstplpage (+ 13 97) "5 Failure, Input-Output, and Continuations")
;; (find-reynoldstplpage (+ 13 97) "5.1 The fail Command")
;; (find-reynoldstplpage (+ 13 101) "5.2 Intermediate Output and a Domain of Sequences")
;; (find-reynoldstplpage (+ 13 107) "5.3 The Physical Argument for Continuity")
;; (find-reynoldstplpage (+ 13 109) "5.4 Products and Disjoint Unions of Predomains")
;; (find-reynoldstplpage (+ 13 111) "5.5 Recursive Domain Isomorphisms")
;; (find-reynoldstplpage (+ 13 113) "5.6 Intermediate Input and a Domain of Resumptions")
;; (find-reynoldstplpage (+ 13 115) "5.7 Continuation Semantics")
;; (find-reynoldstplpage (+ 13 118) "5.8 Continuation Semantics of Extensions")
;; (find-reynoldstplpage (+ 13 126) "6 Transition Semantics")
;; (find-reynoldstplpage (+ 13 126) "6.1 Configurations and the Transition Relation")
;; (find-reynoldstplpage (+ 13 127) "6.2 Inference Rules for the Simple Language")
;; (find-reynoldstplpage (+ 13 131) "6.3 Transition Semantics of fail")
;; (find-reynoldstplpage (+ 13 132) "6.4 Input and Output")
;; (find-reynoldstplpage (+ 13 136) "7 Nondeterminism and Guarded Commands")
;; (find-reynoldstplpage (+ 13 137) "7.1 Syntax and Transition Semantics")
;; (find-reynoldstplpage (+ 13 139) "7.2 Bounded Nondeterminism and Powerdomains")
;; (find-reynoldstplpage (+ 13 144) "7.3 Semantic Equations")
;; (find-reynoldstplpage (+ 13 147) "7.4 Program Specification and Proof")
;; (find-reynoldstplpage (+ 13 149) "7.5 Weakest Preconditions")
;; (find-reynoldstplpage (+ 13 155) "8 Shared-Variable Concurrency")
;; (find-reynoldstplpage (+ 13 155) "8.1 Concurrent Composition")
;; (find-reynoldstplpage (+ 13 157) "8.2 Critical Regions")
;; (find-reynoldstplpage (+ 13 159) "8.3 Mutual Exclusion and Conditional Critical Regions")
;; (find-reynoldstplpage (+ 13 161) "8.4 Deadlock")
;; (find-reynoldstplpage (+ 13 162) "8.5 Fairness")
;; (find-reynoldstplpage (+ 13 164) "8.6 Resumption Semantics")
;; (find-reynoldstplpage (+ 13 165) "8.7 Transition Traces")
;; (find-reynoldstplpage (+ 13 171) "8.8 Stuttering and Mumbling")
;; (find-reynoldstplpage (+ 13 181) "9 Communicating Sequential Processes")
;; (find-reynoldstplpage (+ 13 181) "9.1 Syntax")
;; (find-reynoldstplpage (+ 13 183) "9.2 Transition Semantics")
;; (find-reynoldstplpage (+ 13 187) "9.3 Possible Restrictions")
;; (find-reynoldstplpage (+ 13 188) "9.4 Examples")
;; (find-reynoldstplpage (+ 13 189) "9.5 Deadlock")
;; (find-reynoldstplpage (+ 13 189) "9.6 Fairness")
;; (find-reynoldstplpage (+ 13 194) "10 The Lambda Calculus")
;; (find-reynoldstplpage (+ 13 196) "10.1 Syntax")
;; (find-reynoldstplpage (+ 13 197) "10.2 Reduction")
;; (find-reynoldstplpage (+ 13 201) "10.3 Normal-Order Evaluation")
;; (find-reynoldstplpage (+ 13 206) "10.4 Eager Evaluation")
;; (find-reynoldstplpage (+ 13 208) "10.5 Denotational Semantics")
;; (find-reynoldstplpage (+ 13 216) "10.6 Programming in the Lambda Calculus")
;; (find-reynoldstplpage (+ 13 222) "11 An Eager Functional Language")
;; (find-reynoldstplpage (+ 13 222) "11.1 Concrete Syntax")
;; (find-reynoldstplpage (+ 13 223) "11.2 Evaluation Semantics")
;; (find-reynoldstplpage (+ 13 228) "11.3 Definitions, Patterns, and Recursion")
;; (find-reynoldstplpage (+ 13 231) "11.4 Lists")
;; (find-reynoldstplpage (+ 13 232) "11.5 Examples")
;; (find-reynoldstplpage (+ 13 235) "11.6 Direct Denotational Semantics")
;; (find-reynoldstplpage (+ 13 242) "11.7 Dynamic Binding")
;; (find-reynoldstplpage (+ 13 251) "12 Continuations in a Functional Language")
;; (find-reynoldstplpage (+ 13 251) "12.1 Continuation Semantics")
;; (find-reynoldstplpage (+ 13 255) "12.2 Continuations as Values")
;; (find-reynoldstplpage (+ 13 257) "12.3 Continuations as a Programming Technique")
;; (find-reynoldstplpage (+ 13 258) "12.4 Deriving a First-Order Semantics")
;; (find-reynoldstplpage (+ 13 264) "12.5 First-Order Semantics Summarized")
;; (find-reynoldstplpage (+ 13 269) "12.6 Relating First-Order and Continuation Semantics")
;; (find-reynoldstplpage (+ 13 273) "13 Iswim-like Languages")
;; (find-reynoldstplpage (+ 13 273) "13.1 Aliasing, References, and States")
;; (find-reynoldstplpage (+ 13 276) "13.2 Evaluation Semantics")
;; (find-reynoldstplpage (+ 13 278) "13.3 Continuation Semantics")
;; (find-reynoldstplpage (+ 13 282) "13.4 Some Syntactic Sugar")
;; (find-reynoldstplpage (+ 13 282) "13.5 First-Order Semantics")
;; (find-reynoldstplpage (+ 13 284) "13.6 Examples")
;; (find-reynoldstplpage (+ 13 287) "13.7 Exceptions")
;; (find-reynoldstplpage (+ 13 289) "13.8 Backtracking")
;; (find-reynoldstplpage (+ 13 291) "13.9 Input and Output")
;; (find-reynoldstplpage (+ 13 293) "13.10 Some Complications")
;; (find-reynoldstplpage (+ 13 298) "14 A Normal-Order Language")
;; (find-reynoldstplpage (+ 13 298) "14.1 Evaluation Semantics")
;; (find-reynoldstplpage (+ 13 301) "14.2 Syntactic Sugar")
;; (find-reynoldstplpage (+ 13 302) "14.3 Examples")
;; (find-reynoldstplpage (+ 13 304) "14.4 Direct Denotational Semantics")
;; (find-reynoldstplpage (+ 13 306) "14.5 Reduction Revisited")
;; (find-reynoldstplpage (+ 13 307) "14.6 Lazy Evaluation")
;; (find-reynoldstplpage (+ 13 315) "15 The Simple Type System")
;; (find-reynoldstplpage (+ 13 316) "15.1 Types, Contexts, and Judgements")
;; (find-reynoldstplpage (+ 13 318) "15.2 Inference Rules")
;; (find-reynoldstplpage (+ 13 324) "15.3 Explicit Typing")
;; (find-reynoldstplpage (+ 13 327) "15.4 The Extrinsic Meaning of Types")
;; (find-reynoldstplpage (+ 13 334) "15.5 The Intrinsic View")
;; (find-reynoldstplpage (+ 13 339) "15.6 Set-Theoretic Semantics")
;; (find-reynoldstplpage (+ 13 341) "15.7 Recursive Types")
;; (find-reynoldstplpage (+ 13 349) "16 Subtypes and Intersection Types")
;; (find-reynoldstplpage (+ 13 349) "16.1 Inference Rules for Subtyping")
;; (find-reynoldstplpage (+ 13 352) "16.2 Named Products and Sums")
;; (find-reynoldstplpage (+ 13 354) "16.3 Intersection Types")
;; (find-reynoldstplpage (+ 13 358) "16.4 Extrinsic Semantics")
;; (find-reynoldstplpage (+ 13 362) "16.5 Generic Operators")
;; (find-reynoldstplpage (+ 13 365) "16.6 Intrinsic Semantics")
;; (find-reynoldstplpage (+ 13 379) "17 Polymorphism")
;; (find-reynoldstplpage (+ 13 380) "17.1 Syntax and Inference Rules")
;; (find-reynoldstplpage (+ 13 383) "17.2 Polymorphic Programming")
;; (find-reynoldstplpage (+ 13 390) "17.3 Extrinsic Semantics")
;; (find-reynoldstplpage (+ 13 398) "18 Module Specification")
;; (find-reynoldstplpage (+ 13 398) "18.1 Type Definitions")
;; (find-reynoldstplpage (+ 13 401) "18.2 Existential Quantification and Modules")
;; (find-reynoldstplpage (+ 13 406) "18.3 Implementing One Abstraction in Terms of Another")
;; (find-reynoldstplpage (+ 13 415) "19 Algol-like Languages")
;; (find-reynoldstplpage (+ 13 416) "19.1 Data Types and Phrase Types")
;; (find-reynoldstplpage (+ 13 419) "19.2 Phrases and Type Inference Rules")
;; (find-reynoldstplpage (+ 13 423) "19.3 Examples")
;; (find-reynoldstplpage (+ 13 426) "19.4 Arrays and Declarators")
;; (find-reynoldstplpage (+ 13 428) "19.5 A Semantics Embodying the Stack Discipline")
;; (find-reynoldstplpage (+ 13 434) "19.6 The Semantics of Variables")
;; (find-reynoldstplpage (+ 13 436) "19.7 The Semantics of Procedures")
;; (find-reynoldstplpage (+ 13 439) "19.8 Some Extensions and Simplifications")
;; (find-reynoldstplpage (+ 13 447) "Appendix: Mathematical Background")
;; (find-reynoldstplpage (+ 13 448) "A.1 Sets")
;; (find-reynoldstplpage (+ 13 450) "A.2 Relations")
;; (find-reynoldstplpage (+ 13 452) "A.3 Functions")
;; (find-reynoldstplpage (+ 13 456) "A.4 Relations and Functions Between Sets")
;; (find-reynoldstplpage (+ 13 459) "A.5 More About Products and Disjoint Unions")
;; (find-reynoldstplpage (+ 13 462) "A.6 More About Relations")
;; (find-reynoldstplpage (+ 13 467) "Bibliography")
;; (find-reynoldstplpage (+ 13 483) "Index")
;; «rutten» (to ".rutten")
;; (find-books "__comp/__comp.el" "rutten")
;; "Behavioural differential equations: a coinductive calculus of streams, automata, and power series"
;; https://homepages.cwi.nl/~janr/
;; https://homepages.cwi.nl/~janr/papers/
;; https://homepages.cwi.nl/~janr/papers/files-of-papers/tcs308.pdf
(code-pdf-page "rutten" "$S/https/homepages.cwi.nl/~janr/papers/files-of-papers/tcs308.pdf")
(code-pdf-text "rutten" "$S/https/homepages.cwi.nl/~janr/papers/files-of-papers/tcs308.pdf")
;; (find-ruttenpage)
;; (find-ruttentext)
;; «queinnec» (to ".queinnec")
;; http://pagesperso-systeme.lip6.fr/Christian.Queinnec/WWW/LiSP.html
(code-djvu "queinnec" "~/books/__comp/queinnec__lisp_in_small_pieces.djvu")
(code-djvutotext "queinnec" "~/books/__comp/queinnec__lisp_in_small_pieces.djvu")
;; (find-queinnecpage 3 "Contents")
;; (find-queinnecpage (+ 18 495) "Index")
;; (find-queinnectext "")
;; «salus» (to ".salus")
;; (find-books "__comp/__comp.el" "salus")
(code-pdf-page "salus" "~/books/__comp/salus__a_quarter_century_of_UNIX.pdf")
(code-pdf-text "salus" "~/books/__comp/salus__a_quarter_century_of_UNIX.pdf" 13)
;; (find-saluspage)
;; (find-saluspage 12 "Contents")
;; (find-saluspage (+ 13 1) "Introduction")
;; (find-saluspage (+ 13 3) "Genesis")
;; (find-saluspage (+ 13 5) "0. Prelude to space")
;; (find-saluspage (+ 13 7) "1. Summer 1969-")
;; (find-saluspage (+ 13 12) "2. Calculating and computing")
;; (find-saluspage (+ 13 22) "3. Opearting systems")
;; (find-saluspage (+ 13 25) "4. Project MAC:")
;; (find-saluspage (+ 13 31) "Part 2: Birth of a system")
;; (find-saluspage (+ 13 33) "5. The PDP-11")
;; (find-saluspage (+ 13 38) "6. First edition")
;; (find-saluspage (+ 13 44) "7. C and pipes")
;; (find-saluspage (+ 13 54) "8. The first paper")
;; (find-saluspage (+ 13 56) "9. The law - part I")
;; (find-saluspage (+ 13 63) "Part 3: What makes UNIX Unix?")
;; (find-saluspage (+ 13 65) "10. The users")
;; (find-saluspage (+ 13 73) "11. Why Unix?")
;; (find-saluspage (+ 13 78) "12. Style and tools")
;; (find-saluspage (+ 13 92) "13. PWB and MERT")
;; (find-saluspage (+ 13 95) "14. Utilities")
;; (find-saluspage (+ 13 117) "Part 4: Unix spreads and blossoms")
;; (find-saluspage (+ 13 119) "15. The users - part II")
;; (find-saluspage (+ 21 137) "16. Berkeley Unix - part I")
;; (find-saluspage (+ 21 146) "17. Version 7")
;; (find-saluspage (+ 21 153) "18. Berkeley Unix - part II")
;; (find-saluspage (+ 21 173) "19. Commercial Unix")
;; (find-saluspage (+ 21 181) "20. DEC")
;; (find-saluspage (+ 21 189) "21. The law - part 2")
;; (find-saluspage (+ 21 191) "Part 5: The Unix industry")
;; (find-saluspage (+ 21 193) "22. /usr/group")
;; (find-saluspage (+ 21 198) "23. Sun and JAWS")
;; (find-saluspage (+ 21 202) "24. Standards")
;; (find-saluspage (+ 21 207) "Part 6: The currents of change")
;; (find-saluspage (+ 21 209) "25. Duelling Unixes")
;; (find-saluspage (+ 21 213) "26. Offspring systems")
;; (find-saluspage (+ 21 216) "27. OSF and UI")
;; (find-saluspage (+ 21 219) "28. Berkeley Unix: after the VAX")
;; (find-saluspage (+ 21 222) "29. The law: part III")
;; (find-saluspage (+ 21 227) "Finale")
;; (find-saluspage (+ 21 229) "Finale: what made it work?")
;; (find-saluspage (+ 21 235) "Further reading")
;; (find-saluspage (+ 21 239) "Who's who and what's what")
;; (find-saluspage (+ 21 249) "Index")
;; (find-salustext "")
;; «scheinerman» (to ".scheinerman")
(code-xpdf "scheinerman" "~/books/__comp/scheinerman__matematica_discreta_uma_introducao.pdf")
(code-djvu "scheinerman" "~/books/__comp/scheinerman__matematica_discreta_uma_introducao.djvu")
(code-djvu "scheinerman" "~/books/__comp/scheinerman__matematica_discreta_uma_introducao__bw.djvu")
;; (find-scheinermanpage 1 "Contents")
;; (find-scheinermanpage (+ 1 1) "Index")
;; (find-scheinermantext "")
;; (find-scheinermanpage (+ 8 1) "Capítulo 1. Fundamentos")
;; (find-scheinermanpage (+ 8 1) "Seção 1. Definição")
;; (find-scheinermanpage (+ 7 7) "Seção 2. Teorema")
;; (find-scheinermanpage (+ 6 16) "Seção 3. Prova")
;; (find-scheinermanpage (+ 6 20) "Esquema de prova 1" "se-então")
;; (find-scheinermanpage (+ 6 22) "Omitindo passos")
;; (find-scheinermanpage (+ 4 25) "Seção 4. Contra-exemplo")
;; (find-scheinermanpage (+ 4 27) "Seção 5. Álgebra de Boole")
;; (find-scheinermanpage (+ 4 29) "Equivalência lógica")
;; (find-scheinermanpage (+ 0 33) "(exercícios)")
;; (find-scheinermanpage (+ 0 35) "Capítulo 2. Coleções")
;; (find-scheinermanpage (+ 0 35) "Seção 6. Listas")
;; (find-scheinermanpage (+ -6 44) "Seção 7. Fatorial")
;; (find-scheinermanpage (+ -6 49) "Seção 8. Conjuntos I: Introdução, Subconjuntos")
;; (find-scheinermanpage (+ -7 56) "Seção 9. Quantificadores")
;; (find-scheinermanpage (+ -10 62) "Seção 10. Conjuntos II: Operações")
;; (find-scheinermanpage (+ -10 77) "Capítulo 3. Contagem e Relações")
;; (find-scheinermanpage (+ -10 77) "Seção 11. Relações")
;; (find-scheinermanpage (+ -10 83) "Ilustração de relações")
;; (find-scheinermanpage (+ -10 84) "Seção 12. Relações de Equivalência")
;; (find-scheinermanpage (+ -10 93) "Seção 13. Partições")
;; (find-scheinermanpage (+ -15 100) "Seção 14. Coeficientes Binomiais")
;; (find-scheinermanpage (+ -23 116) "Seção 15. Contagem de Multiconjuntos")
;; (find-scheinermanpage (+ -23 124) "Seção 16. Inclusão-Exclusão")
;; (find-scheinermanpage (+ -25 135) "Capítulo 4. Mais Provas")
;; (find-scheinermanpage (+ -25 135) "Seção 17. Contradição")
;; (find-scheinermanpage (+ -25 143) "Seção 18. Contra-exemplo Mínimo")
;; (find-scheinermanpage (+ -27 155) "(indução - exercícios preliminares)")
;; (find-scheinermanpage (+ -27 156) "Seção 19. Indução")
;; (find-scheinermanpage (+ -27 165) "(indução - exercícios mais sérios)")
;; (find-scheinermanpage (+ -27 169) "Capítulo 5. Funções")
;; (find-scheinermanpage (+ -27 170) "Seção 20. Funções")
;; (find-scheinermanpage (+ -29 184) "Seção 21. O Princípio da Casa do Pombo")
;; (find-scheinermanpage (+ -31 191) "Seção 22. Composição")
;; (find-scheinermanpage (+ -31 197) "Seção 23. Permutações")
;; (find-scheinermanpage (+ -31 212) "Seção 24. Simetria")
;; (find-scheinermanpage (+ -31 219) "Seção 25. Tipos de Notação")
;; (find-scheinermanpage (+ -38 227) "Capítulo 6. Probabilidade")
;; (find-scheinermanpage (+ -38 228) "Seção 26. Espaço Amostral")
;; (find-scheinermanpage (+ -38 232) "Seção 27. Eventos")
;; (find-scheinermanpage (+ -41 241) "Seção 28. Probabilidade Condicional e Independência")
;; (find-scheinermanpage (+ -41 252) "Seção 29. Variáveis Aleatórias")
;; (find-scheinermanpage (+ -55 258) "Seção 30. Esperança")
;; (find-scheinermanpage (+ -55 279) "Capítulo 7. Teoria dos Números")
;; (find-scheinermanpage (+ -55 279) "Seção 31. Divisão")
;; (find-scheinermanpage (+ -55 285) "Seção 32. Máximo Divisor Comum")
;; (find-scheinermanpage (+ -64 296) "Seção 33. Aritmética Modular")
;; (find-scheinermanpage (+ -64 308) "Seção 34. O Teorema do Resto Chinês")
;; (find-scheinermanpage (+ -64 314) "Seção 35. Fatoração")
;; (find-scheinermanpage (+ -69 325) "Capítulo 8. Álgebra")
;; (find-scheinermanpage (+ -69 325) "Seção 36. Grupos")
;; (find-scheinermanpage (+ -69 336) "Seção 37. Isomorfismo de Grupos")
;; (find-scheinermanpage (+ -69 343) "Seção 38. Subgrupos")
;; (find-scheinermanpage (+ -78 352) "Seção 39. O Pequeno Teorema de Fermat")
;; (find-scheinermanpage (+ -78 361) "Seção 40. Criptografia de Chave Pública I: Introdução")
;; (find-scheinermanpage (+ -78 366) "Seção 41. Criptografia de Chave Pública II: O Método de Rabin")
;; (find-scheinermanpage (+ -78 373) "Seção 42. Criptografia de Chave Pública III: RSA")
;; (find-scheinermanpage (+ -90 381) "Capítulo 9. Grafos")
;; (find-scheinermanpage (+ -93 381) "Seção 43. Fundamentos da Teoria dos Grafos")
;; (find-scheinermanpage (+ -95 394) "Seção 44. Subgrafos")
;; (find-scheinermanpage (+ -100 402) "Seção 45. Conexão")
;; (find-scheinermanpage (+ -102 411) "Seção 46. Árvores")
;; (find-scheinermanpage (+ -105 422) "Seção 47. Grafos Eulerianos")
;; (find-scheinermanpage (+ -107 428) "Seção 48. Coloração")
;; (find-scheinermanpage (+ -109 439) "Seção 49. Grafos Planares")
;; (find-scheinermanpage (+ -115 453) "Capítulo 10. Conjuntos Parcialmente Ordenados")
;; (find-scheinermanpage (+ -115 453) "Seção 50. Fundamentos dos Conjuntos Parcialmente Ordenados")
;; (find-scheinermanpage (+ -115 454) "diagrama de Hasse")
;; (find-scheinermanpage (+ -119 461) "Seção 51. Max e Min")
;; (find-scheinermanpage (+ -119 464) "Seção 52. Ordens Lineares")
;; (find-scheinermanpage (+ -121 468) "Seção 53. Extensões Lineares")
;; (find-scheinermanpage (+ -125 477) "Seção 54. Dimensão")
;; (find-scheinermanpage (+ -129 485) "Seção 55. Reticulados")
;; (find-scheinermanpage (+ -129 493) "Apêndices")
;; (find-scheinermanpage (+ -132 493) "Apêndice A. Muitas Sugestões e Comentários, Algumas Respostas")
;; (find-scheinermanpage (+ -116 515) "Apêndice B. Glossário")
;; (find-scheinermanpage (+ -117 522) "Apêndice C. Fundamentos")
;; (find-scheinermanpage (+ -118 525) "Esquemas de prova")
;; (find-scheinermanpage (+ -118 527) "Índice remissivo")
;; «sedgewick» (to ".sedgewick")
;; (find-books "__comp/__comp.el" "sedgewick")
(code-pdf-page "sedgewickC" "~/books/__comp/sedgewick__algorithms_in_C.pdf")
(code-pdf-text "sedgewickC" "~/books/__comp/sedgewick__algorithms_in_C.pdf" 1)
;; (find-sedgewickCpage)
;; (find-sedgewickCpage 12 "Contents")
;; (find-sedgewickCpage (+ 15 3) "1.")
;; (find-sedgewickCpage (+ 15 19) "Figure 3.3. Rearranging a linked list")
;; (find-sedgewickCpage (+ 15 643) "Program Index")
;; (find-sedgewickCpage (+ 15 647) "Index")
;; (find-sedgewickCtext "")
(code-pdf-page "sedgewickw4" "~/books/__comp/sedgewick_wayne__algorithms_4th_ed.pdf")
(code-pdf-text "sedgewickw4" "~/books/__comp/sedgewick_wayne__algorithms_4th_ed.pdf" 1)
;; (find-sedgewickw4page)
;; (find-sedgewickw4page 1 "Contents")
;; (find-sedgewickw4page (+ 1 189) "Index")
;; (find-sedgewickw4text "")
(code-xpdf "sedgewick" "~/books/__comp/sedgewick__algorithms_in_c.pdf")
(code-djvu "sedgewick" "~/books/__comp/sedgewick__algorithms_in_c.djvu")
;; (find-sedgewickpage 12 "Contents")
;; (find-sedgewickpage (+ 15 647) "Index")
;; 1st edition, 1983:
;; http://thepiratebay.se/torrent/4870389/Algorithms_-_Robert_Sedgewick
;; (find-xpdfpage "sedgewick" "~/books/__comp/sedgewick__algorithms.pdf")
;; «seibel» (to ".seibel")
;; http://gigapedia.com/items/374054/coders-at-work---reflections-on-the-craft-of-programming
(code-xpdf "codersatwork" "~/books/__comp/seibel__coders_at_work.pdf")
(code-pdftotext "codersatwork" "~/books/__comp/seibel__coders_at_work.pdf")
;; (find-codersatworkpage 8 "Contents")
;; (find-codersatworkpage (+ 16 449) "Ken Thompson")
;; (find-codersatworkpage (+ 16 607) "Index")
;; (find-codersatworktext "")
;; (find-codersatworktext 13 "believe that they know what they were talking about")
;; (find-codersatworktext 16 "Fuck off!")
;; (find-codersatworktext 20 "which ten percent of the language is safe to use")
;; (find-codersatworktext 45 "three orders of magnitude wrong")
;; (find-codersatworktext 47 "There are no user-serviceable parts anymore")
;; (find-codersatworktext 71 "And then they reply.")
;; (find-codersatworktext 88 "same people writing the air-traffic-control system")
;; (find-codersatworktext 124 "write in your native language")
;; (find-codersatworktext 130 "Windows programmers")
;; (find-codersatworktext 292 "Getting along with people")
;; (find-codersatworktext 332 "It was possible to do a core dump and inspect every word")
;; (find-codersatworktext 366 "ha ha, this proof has a bug in it")
;; (find-codersatworktext 378 "so good they eat their children")
;; (find-codersatworktext 379 "their role is to prepare people to work in an industry")
;; (find-codersatworktext 494 "not thinking at all before you start")
;; (find-codersatworktext 502 "So that was the excuse for C")
;; (find-codersatworktext 507 "an awful lot of them come from farm kids")
;; (find-codersatworktext 510 "it was a profession")
;; «steele-common-lisp» (to ".steele-common-lisp")
;; (find-books "__comp/__comp.el" "steele-common-lisp")
(code-pdf-page "steelecommonlisp" "~/books/__comp/steele__common_lisp_the_language_2nd_ed.pdf")
(code-pdf-text "steelecommonlisp" "~/books/__comp/steele__common_lisp_the_language_2nd_ed.pdf" 1)
;; (find-steelecommonlisppage)
;; (find-steelecommonlisppage 1 "Contents")
;; (find-steelecommonlisppage (+ 1 189) "Index")
;; (find-steelecommonlisptext "")
;; «steele-gabriel» (to ".steele-gabriel")
;; (find-books "__comp/__comp.el" "steele-gabriel")
;; Steele/Gabriel: "The Evolution of Lisp"
;; https://www.dreamsongs.com/Files/HOPL2-Uncut.pdf
;; https://dl.acm.org/doi/10.1145/155360.155373
(code-pdf-page "evolisp" "$S/https/www.dreamsongs.com/Files/HOPL2-Uncut.pdf")
(code-pdf-text "evolisp" "$S/https/www.dreamsongs.com/Files/HOPL2-Uncut.pdf")
;; (find-evolisppage)
;; (find-evolisptext)
1
;; «stevenson» (to ".stevenson")
;; https://news.ycombinator.com/item?id=12469797 In the Beginning Was the Command Line (1999) (inria.fr)
;; There's another essay on interfaces, which I cannot presently
;; place, that describes the situation in another way -- that the GUI
;; folder, and colour, and listing, and columns, aren't themselves
;; representative of how the OS sees or organises its content, nor do
;; the actions a user practices on the desktop correspond in large
;; part to what's happening at the underlying level.
;; "emacs outshines all other editing software in approximately the
;; same way that the noonday sun does the stars. It is not just bigger
;; and brighter; it simply makes everything else vanish"
;; http://garote.bdmonkeys.net/commandline/index.html
;; «stroustrup» (to ".stroustrup")
(code-djvu "stroustrupdaecpp" "~/books/__comp/stroustrup__the_design_and_evolution_of_C++.djvu")
(code-djvutotext "stroustrupdaecpp" "~/books/__comp/stroustrup__the_design_and_evolution_of_C++.djvu")
;; (find-stroustrupdaecpppage 1 "Contents")
;; (find-stroustrupdaecpppage (+ 1 1) "Index")
;; (find-stroustrupdaecpptext "")
;; «sussman-wisdom» (to ".sussman-wisdom")
;; (find-books "__comp/__comp.el" "sussman-wisdom")
;; https://en.wikipedia.org/wiki/Structure_and_Interpretation_of_Classical_Mechanics
;; https://groups.csail.mit.edu/mac/users/gjs/6946/
(code-pdf-page "sicm" "~/books/__comp/sussman_wisdom__structure_and_interpretation_of_classical_mechanics.pdf")
(code-pdf-text "sicm" "~/books/__comp/sussman_wisdom__structure_and_interpretation_of_classical_mechanics.pdf" 20)
;; (find-sicmpage)
;; (find-sicmpage 6 "Contents")
;; (find-sicmtext 6 "Contents")
;; (find-sicmpage 12 "mathematical pedagogy")
;; (find-sicmtext 12 "mathematical pedagogy")
;; (find-sicmpage 13 "functional notation")
;; (find-sicmtext 13 "functional notation")
;; (find-sicmpage (+ 20 1) "1 Lagrangian Mechanics")
;; (find-sicmpage (+ 20 4) "1.1 Configuration Spaces")
;; (find-sicmpage (+ 20 6) "1.2 Generalized Coordinates")
;; (find-sicmpage (+ 20 8) "1.3 The Principle of Stationary Action")
;; (find-sicmpage (+ 20 14) "1.4 Computing Actions")
;; (find-sicmpage (+ 20 14) "as a procedure")
;; (find-sicmtext (+ 20 14) "as a procedure")
;; (find-sicmpage (+ 20 23) "1.5 The Euler-Lagrange Equations")
;; (find-sicmpage (+ 20 25) "1.5.1 Derivation of the Lagrange Equations")
;; (find-sicmpage (+ 20 25) "correct use of the traditional notation")
;; (find-sicmtext (+ 20 25) "correct use of the traditional notation")
;; (find-sicmpage (+ 20 33) "1.5.2 Computing Lagrange's Equations")
;; (find-sicmpage (+ 20 36) "1.6 How to Find Lagrangians")
;; (find-sicmpage (+ 20 44) "1.6.1 Coordinate Transformations")
;; (find-sicmpage (+ 20 49) "1.6.2 Systems with Rigid Constraints")
;; (find-sicmpage (+ 20 59) "1.6.3 Constraints as Coordinate Transformations")
;; (find-sicmpage (+ 20 63) "1.6.4 The Lagrangian Is Not Unique")
;; (find-sicmpage (+ 20 68) "1.7 Evolution of Dynamical State")
;; (find-sicmpage (+ 20 78) "1.8 Conserved Quantities")
;; (find-sicmpage (+ 20 79) "1.8.1 Conserved Momenta")
;; (find-sicmpage (+ 20 81) "1.8.2 Energy Conservation")
;; (find-sicmpage (+ 20 84) "1.8.3 Central Forces in Three Dimensions")
;; (find-sicmpage (+ 20 86) "1.8.4 The Restricted Three-Body Problem")
;; (find-sicmpage (+ 20 90) "1.8.5 Noether's Theorem")
;; (find-sicmpage (+ 20 94) "1.9 Abstraction of Path Functions")
;; (find-sicmpage (+ 20 99) "1.10 Constrained Motion")
;; (find-sicmpage (+ 20 101) "1.10.1 Coordinate Constraints")
;; (find-sicmpage (+ 20 108) "1.10.2 Derivative Constraints")
;; (find-sicmpage (+ 20 112) "1.10.3 Nonholonomic Systems")
;; (find-sicmpage (+ 20 115) "1.11 Summary")
;; (find-sicmpage (+ 20 116) "1.12 Projects")
;; (find-sicmpage (+ 20 119) "2 Rigid Bodies")
;; (find-sicmpage (+ 20 120) "2.1 Rotational Kinetic Energy")
;; (find-sicmpage (+ 20 122) "2.2 Kinematics of Rotation")
;; (find-sicmpage (+ 20 126) "2.3 Moments of Inertia")
;; (find-sicmpage (+ 20 130) "2.4 Inertia Tensor")
;; (find-sicmpage (+ 20 132) "2.5 Principal Moments of Inertia")
;; (find-sicmpage (+ 20 135) "2.6 Vector Angular Momentum")
;; (find-sicmpage (+ 20 137) "2.7 Euler Angles")
;; (find-sicmpage (+ 20 141) "2.8 Motion of a Free Rigid Body")
;; (find-sicmpage (+ 20 143) "2.8.1 Computing the Motion of Free Rigid Bodies")
;; (find-sicmpage (+ 20 146) "2.8.2 Qualitative Features")
;; (find-sicmpage (+ 20 151) "2.9 Euler's Equations")
;; (find-sicmpage (+ 20 157) "2.10 Axisymmetric Tops")
;; (find-sicmpage (+ 20 165) "2.11 Spin-Orbit Coupling")
;; (find-sicmpage (+ 20 165) "2.11.1 Development of the Potential Energy")
;; (find-sicmpage (+ 20 170) "2.11.2 Rotation of the Moon and Hyperion")
;; (find-sicmpage (+ 20 177) "2.11.3 Spin-Orbit Resonances")
;; (find-sicmpage (+ 20 181) "2.12 Nonsingular Coordinates and Quaternions")
;; (find-sicmpage (+ 20 188) "2.12.1 Motion in Terms of Quaternions")
;; (find-sicmpage (+ 20 191) "2.13 Summary")
;; (find-sicmpage (+ 20 193) "2.14 Projects")
;; (find-sicmpage (+ 19 195) "3 Hamiltonian Mechanics")
;; (find-sicmpage (+ 19 197) "3.1 Hamilton's Equations")
;; (find-sicmpage (+ 19 205) "3.1.1 The Legendre Transformation")
;; (find-sicmpage (+ 19 215) "3.1.2 Hamilton's Equations from the Action Principle")
;; (find-sicmpage (+ 19 217) "3.1.3 A Wiring Diagram")
;; (find-sicmpage (+ 19 218) "3.2 Poisson Brackets")
;; (find-sicmpage (+ 19 222) "3.3 One Degree of Freedom")
;; (find-sicmpage (+ 19 224) "3.4 Phase Space Reduction")
;; (find-sicmpage (+ 19 233) "3.4.1 Lagrangian Reduction")
;; (find-sicmpage (+ 19 236) "3.5 Phase Space Evolution")
;; (find-sicmpage (+ 19 238) "3.5.1 Phase-Space Description Is Not Unique")
;; (find-sicmpage (+ 19 239) "3.6 Surfaces of Section")
;; (find-sicmpage (+ 19 241) "3.6.1 Periodically Driven Systems")
;; (find-sicmpage (+ 19 246) "3.6.2 Computing Stroboscopic Surfaces of Section")
;; (find-sicmpage (+ 19 248) "3.6.3 Autonomous Systems")
;; (find-sicmpage (+ 19 261) "3.6.4 Computing Henon-Heiles Surfaces of Section")
;; (find-sicmpage (+ 19 263) "3.6.5 Non-Axisymmetric Top")
;; (find-sicmpage (+ 19 263) "3.7 Exponential Divergence")
;; (find-sicmpage (+ 19 268) "3.8 Liouville's Theorem")
;; (find-sicmpage (+ 19 277) "3.9 Standard Map")
;; (find-sicmpage (+ 19 281) "3.10 Summary")
;; (find-sicmpage (+ 19 282) "3.11 Projects")
;; (find-sicmpage (+ 18 285) "4 Phase Space Structure")
;; (find-sicmpage (+ 18 286) "4.1 Emergence of the Divided Phase Space")
;; (find-sicmpage (+ 18 290) "4.2 Linear Stability")
;; (find-sicmpage (+ 18 291) "4.2.1 Equilibria of Differential Equations")
;; (find-sicmpage (+ 18 295) "4.2.2 Fixed Points of Maps")
;; (find-sicmpage (+ 18 297) "4.2.3 Relations Among Exponents")
;; (find-sicmpage (+ 18 302) "4.3 Homoclinic Tangle")
;; (find-sicmpage (+ 18 307) "4.3.1 Computation of Stable and Unstable Manifolds")
;; (find-sicmpage (+ 18 309) "4.4 Integrable Systems")
;; (find-sicmpage (+ 18 316) "4.5 Poincare-Birkhoff Theorem")
;; (find-sicmpage (+ 18 321) "4.5.1 Computing the Poincare-Birkhoff Construction")
;; (find-sicmpage (+ 18 322) "4.6 Invariant Curves")
;; (find-sicmpage (+ 18 326) "4.6.1 Finding Invariant Curves")
;; (find-sicmpage (+ 18 329) "4.6.2 Dissolution of Invariant Curves")
;; (find-sicmpage (+ 18 330) "4.7 Summary")
;; (find-sicmpage (+ 18 333) "4.8 Projects")
;; (find-sicmpage (+ 17 335) "5 Canonical Transformations")
;; (find-sicmpage (+ 17 336) "5.1 Point Transformations")
;; (find-sicmpage (+ 17 342) "5.2 General Canonical Transformations")
;; (find-sicmpage (+ 17 347) "5.2.1 Time-Dependent Transformations")
;; (find-sicmpage (+ 17 350) "5.2.2 Abstracting the Canonical Condition")
;; (find-sicmpage (+ 17 357) "5.3 Invariants of Canonical Transformations")
;; (find-sicmpage (+ 17 364) "5.4 Generating Functions")
;; (find-sicmpage (+ 17 366) "5.4.1 F1 Generates Canonical Transformations")
;; (find-sicmpage (+ 17 368) "5.4.2 Generating Functions and Integral Invariants")
;; (find-sicmpage (+ 17 373) "5.4.3 Types of Generating Functions")
;; (find-sicmpage (+ 17 375) "5.4.4 Point Transformations")
;; (find-sicmpage (+ 17 390) "5.4.5 Total Time Derivatives")
;; (find-sicmpage (+ 17 394) "5.5 Extended Phase Space")
;; (find-sicmpage (+ 17 402) "5.5.1 Poincare-Cartan Integral Invariant")
;; (find-sicmpage (+ 17 402) "5.6 Reduced Phase Space")
;; (find-sicmpage (+ 17 408) "5.7 Summary")
;; (find-sicmpage (+ 17 408) "5.8 Projects")
;; (find-sicmpage (+ 17 411) "6 Canonical Evolution")
;; (find-sicmpage (+ 17 411) "6.1 Hamilton-Jacobi Equation")
;; (find-sicmpage (+ 17 413) "6.1.1 Harmonic Oscillator")
;; (find-sicmpage (+ 17 417) "6.1.2 Hamilton-Jacobi Solution of the Kepler Problem")
;; (find-sicmpage (+ 17 421) "6.1.3 F2 and the Lagrangian")
;; (find-sicmpage (+ 17 423) "6.1.4 The Action Generates Time Evolution")
;; (find-sicmpage (+ 17 426) "6.2 Time Evolution is Canonical")
;; (find-sicmpage (+ 17 431) "6.2.1 Another View of Time Evolution")
;; (find-sicmpage (+ 17 435) "6.2.2 Yet Another View of Time Evolution")
;; (find-sicmpage (+ 17 437) "6.3 Lie Transforms")
;; (find-sicmpage (+ 17 443) "6.4 Lie Series")
;; (find-sicmpage (+ 17 451) "6.5 Exponential Identities")
;; (find-sicmpage (+ 17 453) "6.6 Summary")
;; (find-sicmpage (+ 17 453) "6.7 Projects")
;; (find-sicmpage (+ 17 457) "7 Canonical Perturbation Theory")
;; (find-sicmpage (+ 17 458) "7.1 Perturbation Theory with Lie Series")
;; (find-sicmpage (+ 17 460) "7.2 Pendulum as a Perturbed Rotor")
;; (find-sicmpage (+ 17 468) "7.2.1 Higher Order")
;; (find-sicmpage (+ 17 471) "7.2.2 Eliminating Secular Terms")
;; (find-sicmpage (+ 17 473) "7.3 Many Degrees of Freedom")
;; (find-sicmpage (+ 17 476) "7.3.1 Driven Pendulum as a Perturbed Rotor")
;; (find-sicmpage (+ 17 478) "7.4 Nonlinear Resonance")
;; (find-sicmpage (+ 17 480) "7.4.1 Pendulum Approximation")
;; (find-sicmpage (+ 17 488) "7.4.2 Reading the Hamiltonian")
;; (find-sicmpage (+ 17 488) "7.4.3 Resonance-Overlap Criterion")
;; (find-sicmpage (+ 17 489) "7.4.4 Higher-Order Perturbation Theory")
;; (find-sicmpage (+ 17 491) "7.4.5 Stability of the Inverted Vertical Equilibrium")
;; (find-sicmpage (+ 17 494) "7.5 Summary")
;; (find-sicmpage (+ 17 496) "7.6 Projects")
;; (find-sicmpage (+ 17 497) "8 Appendix: Scheme")
;; (find-sicmpage (+ 17 509) "9 Appendix: Our Notation")
;; (find-sicmpage (+ 16 525) "References")
;; (find-sicmpage (+ 15 529) "List of Exercises")
;; (find-sicmpage (+ 14 531) "Index")
;; (find-sicmtext "")
;; «thain» (to ".thain")
;; (find-books "__comp/__comp.el" "thain")
;; Douglas Thain: "Introduction to Compilers and Language Design" (2nd ed)
;; https://www3.nd.edu/~dthain/compilerbook/
;; https://www3.nd.edu/~dthain/compilerbook/compilerbook.pdf
;; https://github.com/dthain/compilerbook-examples
;; https://www.reddit.com/r/programming/comments/3tgryd/recommendations_for_books_on_compilers/
(code-pdf-page "thain" "$S/https/www3.nd.edu/~dthain/compilerbook/compilerbook.pdf")
(code-pdf-text "thain" "$S/https/www3.nd.edu/~dthain/compilerbook/compilerbook.pdf" 14)
;; (find-thainpage)
;; (find-thaintext)
;; (find-thainpage 7 "Contents")
;; (find-thaintext 7 "Contents")
;; (find-thainpage (+ 14 1) "1 Introduction")
;; (find-thainpage (+ 14 1) "1.1 What is a compiler?")
;; (find-thainpage (+ 14 2) "1.2 Why should you study compilers?")
;; (find-thainpage (+ 14 2) "1.3 What's the best way to learn about compilers?")
;; (find-thainpage (+ 14 2) "1.4 What language should I use?")
;; (find-thainpage (+ 14 3) "1.5 How is this book different from others?")
;; (find-thainpage (+ 14 4) "1.6 What other books should I read?")
;; (find-thainpage (+ 14 5) "2 A Quick Tour")
;; (find-thainpage (+ 14 5) "2.1 The Compiler Toolchain")
;; (find-thainpage (+ 14 6) "2.2 Stages Within a Compiler")
;; (find-thainpage (+ 14 7) "2.3 Example Compilation")
;; (find-thainpage (+ 14 10) "2.4 Exercises")
;; (find-thainpage (+ 14 11) "3 Scanning")
;; (find-thainpage (+ 14 11) "3.1 Kinds of Tokens")
;; (find-thainpage (+ 14 12) "3.2 A Hand-Made Scanner")
;; (find-thainpage (+ 14 13) "3.3 Regular Expressions")
;; (find-thainpage (+ 14 15) "3.4 Finite Automata")
;; (find-thainpage (+ 14 16) "3.4.1 Deterministic Finite Automata")
;; (find-thainpage (+ 14 17) "3.4.2 Nondeterministic Finite Automata")
;; (find-thainpage (+ 14 19) "3.5 Conversion Algorithms")
;; (find-thainpage (+ 14 19) "3.5.1 Converting REs to NFAs")
;; (find-thainpage (+ 14 22) "3.5.2 Converting NFAs to DFAs")
;; (find-thainpage (+ 14 24) "3.5.3 Minimizing DFAs")
;; (find-thainpage (+ 14 26) "3.6 Limits of Finite Automata")
;; (find-thainpage (+ 14 26) "3.7 Using a Scanner Generator")
;; (find-thainpage (+ 14 28) "3.8 Practical Considerations")
;; (find-thainpage (+ 14 31) "3.9 Exercises")
;; (find-thainpage (+ 14 33) "3.10 Further Reading")
;; (find-thainpage (+ 14 35) "4 Parsing")
;; (find-thainpage (+ 14 35) "4.1 Overview")
;; (find-thainpage (+ 14 36) "4.2 Context Free Grammars")
;; (find-thainpage (+ 14 37) "4.2.1 Deriving Sentences")
;; (find-thainpage (+ 14 38) "4.2.2 Ambiguous Grammars")
;; (find-thainpage (+ 14 40) "4.3 LL Grammars")
;; (find-thainpage (+ 14 41) "4.3.1 Eliminating Left Recursion")
;; (find-thainpage (+ 14 42) "4.3.2 Eliminating Common Left Prefixes")
;; (find-thainpage (+ 14 43) "4.3.3 First and Follow Sets")
;; (find-thainpage (+ 14 45) "4.3.4 Recursive Descent Parsing")
;; (find-thainpage (+ 14 47) "4.3.5 Table Driven Parsing")
;; (find-thainpage (+ 14 49) "4.4 LR Grammars")
;; (find-thainpage (+ 14 50) "4.4.1 Shift-Reduce Parsing")
;; (find-thainpage (+ 14 51) "4.4.2 The LR(0) Automaton")
;; (find-thainpage (+ 14 55) "4.4.3 SLR Parsing")
;; (find-thainpage (+ 14 59) "4.4.4 LR(1) Parsing")
;; (find-thainpage (+ 14 62) "4.4.5 LALR Parsing")
;; (find-thainpage (+ 14 62) "4.5 Grammar Classes Revisited")
;; (find-thainpage (+ 14 63) "4.6 The Chomsky Hierarchy")
;; (find-thainpage (+ 14 65) "4.7 Exercises")
;; (find-thainpage (+ 14 67) "4.8 Further Reading")
;; (find-thainpage (+ 14 69) "5 Parsing in Practice")
;; (find-thainpage (+ 14 70) "5.1 The Bison Parser Generator")
;; (find-thainpage (+ 14 73) "5.2 Expression Validator")
;; (find-thainpage (+ 14 74) "5.3 Expression Interpreter")
;; (find-thainpage (+ 14 75) "5.4 Expression Trees")
;; (find-thainpage (+ 14 81) "5.5 Exercises")
;; (find-thainpage (+ 14 83) "5.6 Further Reading")
;; (find-thainpage (+ 14 85) "6 The Abstract Syntax Tree")
;; (find-thainpage (+ 14 85) "6.1 Overview")
;; (find-thainpage (+ 14 86) "6.2 Declarations")
;; (find-thainpage (+ 14 88) "6.3 Statements")
;; (find-thainpage (+ 14 90) "6.4 Expressions")
;; (find-thainpage (+ 14 92) "6.5 Types")
;; (find-thainpage (+ 14 95) "6.6 Putting it All Together")
;; (find-thainpage (+ 14 96) "6.7 Building the AST")
;; (find-thainpage (+ 14 98) "6.8 Exercises")
;; (find-thainpage (+ 14 99) "7 Semantic Analysis")
;; (find-thainpage (+ 14 100) "7.1 Overview of Type Systems")
;; (find-thainpage (+ 14 103) "7.2 Designing a Type System")
;; (find-thainpage (+ 14 106) "7.3 The B-Minor Type System")
;; (find-thainpage (+ 14 107) "7.4 The Symbol Table")
;; (find-thainpage (+ 14 111) "7.5 Name Resolution")
;; (find-thainpage (+ 14 113) "7.6 Implementing Type Checking")
;; (find-thainpage (+ 14 117) "7.7 Error Messages")
;; (find-thainpage (+ 14 118) "7.8 Exercises")
;; (find-thainpage (+ 14 118) "7.9 Further Reading")
;; (find-thainpage (+ 14 119) "8 Intermediate Representations")
;; (find-thainpage (+ 14 119) "8.1 Introduction")
;; (find-thainpage (+ 14 119) "8.2 Abstract Syntax Tree")
;; (find-thainpage (+ 14 120) "8.3 Directed Acyclic Graph")
;; (find-thainpage (+ 14 125) "8.4 Control Flow Graph")
;; (find-thainpage (+ 14 127) "8.5 Static Single Assignment Form")
;; (find-thainpage (+ 14 128) "8.6 Linear IR")
;; (find-thainpage (+ 14 129) "8.7 Stack Machine IR")
;; (find-thainpage (+ 14 130) "8.8 Examples")
;; (find-thainpage (+ 14 130) "8.8.1 GIMPLE - GNU Simple Representation")
;; (find-thainpage (+ 14 131) "8.8.2 LLVM - Low Level Virtual Machine")
;; (find-thainpage (+ 14 132) "8.8.3 JVM - Java Virtual Machine")
;; (find-thainpage (+ 14 133) "8.9 Exercises")
;; (find-thainpage (+ 14 134) "8.10 Further Reading")
;; (find-thainpage (+ 14 135) "9 Memory Organization")
;; (find-thainpage (+ 14 135) "9.1 Introduction")
;; (find-thainpage (+ 14 135) "9.2 Logical Segmentation")
;; (find-thainpage (+ 14 138) "9.3 Heap Management")
;; (find-thainpage (+ 14 140) "9.4 Stack Management")
;; (find-thainpage (+ 14 141) "9.4.1 Stack Calling Convention")
;; (find-thainpage (+ 14 142) "9.4.2 Register Calling Convention")
;; (find-thainpage (+ 14 143) "9.5 Locating Data")
;; (find-thainpage (+ 14 146) "9.6 Program Loading")
;; (find-thainpage (+ 14 148) "9.7 Further Reading")
;; (find-thainpage (+ 14 149) "10 Assembly Language")
;; (find-thainpage (+ 14 149) "10.1 Introduction")
;; (find-thainpage (+ 14 150) "10.2 Open Source Assembler Tools")
;; (find-thainpage (+ 14 152) "10.3 X86 Assembly Language")
;; (find-thainpage (+ 14 152) "10.3.1 Registers and Data Types")
;; (find-thainpage (+ 14 154) "10.3.2 Addressing Modes")
;; (find-thainpage (+ 14 156) "10.3.3 Basic Arithmetic")
;; (find-thainpage (+ 14 158) "10.3.4 Comparisons and Jumps")
;; (find-thainpage (+ 14 159) "10.3.5 The Stack")
;; (find-thainpage (+ 14 160) "10.3.6 Calling a Function")
;; (find-thainpage (+ 14 162) "10.3.7 Defining a Leaf Function")
;; (find-thainpage (+ 14 163) "10.3.8 Defining a Complex Function")
;; (find-thainpage (+ 14 167) "10.4 ARM Assembly")
;; (find-thainpage (+ 14 167) "10.4.1 Registers and Data Types")
;; (find-thainpage (+ 14 168) "10.4.2 Addressing Modes")
;; (find-thainpage (+ 14 170) "10.4.3 Basic Arithmetic")
;; (find-thainpage (+ 14 171) "10.4.4 Comparisons and Branches")
;; (find-thainpage (+ 14 173) "10.4.5 The Stack")
;; (find-thainpage (+ 14 174) "10.4.6 Calling a Function")
;; (find-thainpage (+ 14 175) "10.4.7 Defining a Leaf Function")
;; (find-thainpage (+ 14 176) "10.4.8 Defining a Complex Function")
;; (find-thainpage (+ 14 179) "10.4.9 64-bit Differences")
;; (find-thainpage (+ 14 180) "10.5 Further Reading")
;; (find-thainpage (+ 14 181) "11 Code Generation")
;; (find-thainpage (+ 14 181) "11.1 Introduction")
;; (find-thainpage (+ 14 181) "11.2 Supporting Functions")
;; (find-thainpage (+ 14 183) "11.3 Generating Expressions")
;; (find-thainpage (+ 14 188) "11.4 Generating Statements")
;; (find-thainpage (+ 14 192) "11.5 Conditional Expressions")
;; (find-thainpage (+ 14 193) "11.6 Generating Declarations")
;; (find-thainpage (+ 14 194) "11.7 Exercises")
;; (find-thainpage (+ 14 195) "12 Optimization")
;; (find-thainpage (+ 14 195) "12.1 Overview")
;; (find-thainpage (+ 14 196) "12.2 Optimization in Perspective")
;; (find-thainpage (+ 14 197) "12.3 High Level Optimizations")
;; (find-thainpage (+ 14 197) "12.3.1 Constant Folding")
;; (find-thainpage (+ 14 199) "12.3.2 Strength Reduction")
;; (find-thainpage (+ 14 199) "12.3.3 Loop Unrolling")
;; (find-thainpage (+ 14 200) "12.3.4 Code Hoisting")
;; (find-thainpage (+ 14 201) "12.3.5 Function Inlining")
;; (find-thainpage (+ 14 202) "12.3.6 Dead Code Detection and Elimination")
;; (find-thainpage (+ 14 204) "12.4 Low-Level Optimizations")
;; (find-thainpage (+ 14 204) "12.4.1 Peephole Optimizations")
;; (find-thainpage (+ 14 204) "12.4.2 Instruction Selection")
;; (find-thainpage (+ 14 207) "12.5 Register Allocation")
;; (find-thainpage (+ 14 208) "12.5.1 Safety of Register Allocation")
;; (find-thainpage (+ 14 208) "12.5.2 Priority of Register Allocation")
;; (find-thainpage (+ 14 209) "12.5.3 Conflicts Between Variables")
;; (find-thainpage (+ 14 210) "12.5.4 Global Register Allocation")
;; (find-thainpage (+ 14 211) "12.6 Optimization Pitfalls")
;; (find-thainpage (+ 14 212) "12.7 Optimization Interactions")
;; (find-thainpage (+ 14 214) "12.8 Exercises")
;; (find-thainpage (+ 14 215) "12.9 Further Reading")
;; (find-thainpage (+ 14 217) "A Sample Course Project")
;; (find-thainpage (+ 14 217) "A.1 Scanner Assignment")
;; (find-thainpage (+ 14 217) "A.2 Parser Assignment")
;; (find-thainpage (+ 14 218) "A.3 Pretty-Printer Assignment")
;; (find-thainpage (+ 14 218) "A.4 Typechecker Assignment")
;; (find-thainpage (+ 14 218) "A.5 Optional: Intermediate Representation")
;; (find-thainpage (+ 14 218) "A.6 Code Generator Assignment")
;; (find-thainpage (+ 14 219) "A.7 Optional: Extend the Language")
;; (find-thainpage (+ 14 221) "B The B-Minor Language")
;; (find-thainpage (+ 14 221) "B.1 Overview")
;; (find-thainpage (+ 14 222) "B.2 Tokens")
;; (find-thainpage (+ 14 222) "B.3 Types")
;; (find-thainpage (+ 14 223) "B.4 Expressions")
;; (find-thainpage (+ 14 224) "B.5 Declarations and Statements")
;; (find-thainpage (+ 14 224) "B.6 Functions")
;; (find-thainpage (+ 14 225) "B.7 Optional Elements")
;; (find-thainpage (+ 14 227) "C Coding Conventions")
;; (find-thainpage (+ 14 229) "Index")
;; «wilkinson» (to ".wilkinson")
;; http://gigapedia.com/items/50977/the-grammar-of-graphics--second-edition
(code-xpdf "grammarofgraphics" "~/books/__comp/wilkinson__the_grammar_of_graphics.pdf")
(code-pdftotext "grammarofgraphics" "~/books/__comp/wilkinson__the_grammar_of_graphics.pdf")
;; (find-grammarofgraphicspage 12 "Contents")
;; (find-grammarofgraphicspage (+ 2 681) "Index")
;; (find-grammarofgraphicstext "")
;; «yanofsky-mannucci» (to ".yanofsky-mannucci")
;; (find-books "__comp/__comp.el" "yanofsky-mannucci")
(code-pdf-page "quantumccs" "~/books/__comp/yanofsky_mannucci__quantum_computing_for_computer_scientists.pdf")
(code-pdf-text "quantumccs" "~/books/__comp/yanofsky_mannucci__quantum_computing_for_computer_scientists.pdf" 1)
;; (find-quantumccspage)
;; (find-quantumccspage 9 "Contents")
;; (find-quantumccspage (+ 18 381) "Index")
;; (find-quantumccstext "")
;; «zeilberger» (to ".zeilberger")
;; (find-books "__comp/__comp.el" "zeilberger")
;; Noam Zeilberger: "The Logical Basis of Evaluation Order and Pattern-Matching"
;; http://noamz.org/thesis.pdf
(code-pdf-page "zeilbergerthesis" "$S/http/noamz.org/thesis.pdf")
(code-pdf-text "zeilbergerthesis" "$S/http/noamz.org/thesis.pdf")
;; (find-zeilbergerthesispage)
;; (find-zeilbergerthesistext)
;; (find-zeilbergerthesispage (+ 12 1) "1 Introduction")
;; (find-zeilbergerthesispage (+ 12 7) "2 Canonical derivations")
;; (find-zeilbergerthesispage (+ 12 8) "2.1 A proof-biased logic")
;; (find-zeilbergerthesispage (+ 12 8) "2.1.1 Refutation frames, proof patterns, connectives")
;; (find-zeilbergerthesispage (+ 12 9) "2.1.2 The definition ordering")
;; (find-zeilbergerthesispage (+ 12 10) "2.1.3 Proofs and refutations")
;; (find-zeilbergerthesispage (+ 12 12) "2.1.4 Identity and composition")
;; (find-zeilbergerthesispage (+ 12 14) "2.1.5 Complex frames")
;; (find-zeilbergerthesispage (+ 12 16) "2.2 A refutation-biased logic")
;; (find-zeilbergerthesispage (+ 12 16) "2.2.1 Proof frames, refutation patterns, definition ordering")
;; (find-zeilbergerthesispage (+ 12 17) "2.2.2 Proofs and refutations, identity and composition, complex hypotheses")
;; (find-zeilbergerthesispage (+ 12 20) "2.3 Propositional polarized logic")
;; (find-zeilbergerthesispage (+ 12 20) "2.3.1 A unified view")
;; (find-zeilbergerthesispage (+ 12 22) "2.3.2 Atomic propositions")
;; (find-zeilbergerthesispage (+ 12 23) "2.3.3 The entailment relation(s)")
;; (find-zeilbergerthesispage (+ 12 26) "2.4 Linear and affine canonical derivations")
;; (find-zeilbergerthesispage (+ 12 29) "2.5 Related Work")
;; (find-zeilbergerthesispage (+ 12 33) "3 Focusing proofs and double-negation translations")
;; (find-zeilbergerthesispage (+ 12 34) "3.1 Focusing proof search for linear logic")
;; (find-zeilbergerthesispage (+ 12 34) "3.1.1 Naive proof search for linear logic")
;; (find-zeilbergerthesispage (+ 12 36) "3.1.2 Observation #1: Invertibility and the Inversion Phase")
;; (find-zeilbergerthesispage (+ 12 37) "3.1.3 Observation #2: Focalization and the Focus Phase")
;; (find-zeilbergerthesispage (+ 12 38) "3.2 Relating focusing proofs to canonical derivations")
;; (find-zeilbergerthesispage (+ 12 38) "3.2.1 Polarity, invertibility, and focalization")
;; (find-zeilbergerthesispage (+ 12 40) "3.2.2 Focusing proofs, through a microscope")
;; (find-zeilbergerthesispage (+ 12 43) "3.2.3 Focusing proofs, standing back and squinting")
;; (find-zeilbergerthesispage (+ 12 47) "3.2.4 Focusing proofs are canonical derivations")
;; (find-zeilbergerthesispage (+ 12 49) "3.2.5 Complex hypotheses and weak focalization")
;; (find-zeilbergerthesispage (+ 12 49) "3.3 Completeness of focusing proofs")
;; (find-zeilbergerthesispage (+ 12 51) "3.4 Unrestricted derivations and classical sequent calculus")
;; (find-zeilbergerthesispage (+ 12 51) "3.4.1 Polarizations of classical logic")
;; (find-zeilbergerthesispage (+ 12 52) "3.4.2 Focusing proofs for classical sequent calculus")
;; (find-zeilbergerthesispage (+ 12 55) "3.4.3 Classical focusing proofs are unrestricted canonical derivations")
;; (find-zeilbergerthesispage (+ 12 56) "3.4.4 The completeness theorem")
;; (find-zeilbergerthesispage (+ 12 57) "3.5 Relating focusing and double-negation translations")
;; (find-zeilbergerthesispage (+ 12 61) "3.6 Related Work")
;; (find-zeilbergerthesispage (+ 12 63) "4 Proofs as programs")
;; (find-zeilbergerthesispage (+ 12 64) "4.1 Type-free notations for typeful derivations")
;; (find-zeilbergerthesispage (+ 12 66) "4.2 L+ : A call-by-value language")
;; (find-zeilbergerthesispage (+ 12 66) "4.2.1 Continuation frames and value patterns")
;; (find-zeilbergerthesispage (+ 12 67) "4.2.2 Annotated frames, contexts and binding")
;; (find-zeilbergerthesispage (+ 12 68) "4.2.3 Values, continuations, substitutions, expressions")
;; (find-zeilbergerthesispage (+ 12 74) "4.2.4 Is this really syntax?")
;; (find-zeilbergerthesispage (+ 12 75) "4.2.5 Equality, operational semantics, and effects: overview")
;; (find-zeilbergerthesispage (+ 12 76) "4.2.6 Definitional equality")
;; (find-zeilbergerthesispage (+ 12 77) "4.2.7 Identity")
;; (find-zeilbergerthesispage (+ 12 78) "4.2.8 Composition")
;; (find-zeilbergerthesispage (+ 12 78) "4.2.9 Properties of composition")
;; (find-zeilbergerthesispage (+ 12 80) "4.2.10 Complex variables")
;; (find-zeilbergerthesispage (+ 12 81) "4.2.11 Type isomorphisms")
;; (find-zeilbergerthesispage (+ 12 83) "4.2.12 Environment semantics")
;; (find-zeilbergerthesispage (+ 12 85) "4.2.13 Observational equivalence")
;; (find-zeilbergerthesispage (+ 12 86) "4.2.14 Immediate failure, and the chronicle representation")
;; (find-zeilbergerthesispage (+ 12 92) "4.2.15 Ground state, and the separation theorem")
;; (find-zeilbergerthesispage (+ 12 94) "4.3 L: A language with mixed evaluation order")
;; (find-zeilbergerthesispage (+ 12 94) "4.3.1 Continuation patterns and value frames")
;; (find-zeilbergerthesispage (+ 12 95) "4.3.2 Terms")
;; (find-zeilbergerthesispage (+ 12 96) "4.3.3 Mixed polarity types")
;; (find-zeilbergerthesispage (+ 12 99) "4.3.4 Untyped, or "uni-typed"? Better: bi-typed!")
;; (find-zeilbergerthesispage (+ 12 100) "4.3.5 L equality, semantics and effects: overview")
;; (find-zeilbergerthesispage (+ 12 100) "4.3.6 Definitional equality")
;; (find-zeilbergerthesispage (+ 12 101) "4.3.7 Identity")
;; (find-zeilbergerthesispage (+ 12 101) "4.3.8 Composition")
;; (find-zeilbergerthesispage (+ 12 101) "4.3.9 Properties of composition")
;; (find-zeilbergerthesispage (+ 12 102) "4.3.10 Type isomorphisms")
;; (find-zeilbergerthesispage (+ 12 102) "4.3.11 Environment semantics")
;; (find-zeilbergerthesispage (+ 12 103) "4.3.12 Observational equivalence and the separation theorems")
;; (find-zeilbergerthesispage (+ 12 103) "4.4 Polarization and CPS translations")
;; (find-zeilbergerthesispage (+ 12 104) "4.4.1 From -calculus to L+ and back")
;; (find-zeilbergerthesispage (+ 12 107) "4.4.2 Reconstructing call-by-value and call-by-name")
;; (find-zeilbergerthesispage (+ 12 111) "4.4.3 Polarization for fun and profit")
;; (find-zeilbergerthesispage (+ 12 112) "4.5 Related Work")
;; (find-zeilbergerthesispage (+ 12 115) "5 Concrete notations for abstract derivations")
;; (find-zeilbergerthesispage (+ 12 116) "5.1 An embedding of L in Agda")
;; (find-zeilbergerthesispage (+ 12 124) "5.2 An embedding of L+ in Twelf")
;; (find-zeilbergerthesispage (+ 12 134) "5.3 Related work")
;; (find-zeilbergerthesispage (+ 12 135) "6 Refinement types and completeness of subtyping")
;; (find-zeilbergerthesispage (+ 12 135) "6.1 Introduction")
;; (find-zeilbergerthesispage (+ 12 138) "6.2 Refining L+0")
;; (find-zeilbergerthesispage (+ 12 138) "6.2.1 A refinement "restriction"?")
;; (find-zeilbergerthesispage (+ 12 139) "6.2.2 Refining types")
;; (find-zeilbergerthesispage (+ 12 142) "6.2.3 Refining terms")
;; (find-zeilbergerthesispage (+ 12 146) "6.2.4 Refining equality, identity and composition")
;; (find-zeilbergerthesispage (+ 12 146) "6.2.5 Refining complex hypotheses")
;; (find-zeilbergerthesispage (+ 12 147) "6.2.6 Subtyping: the identity coercion interpretation")
;; (find-zeilbergerthesispage (+ 12 149) "6.2.7 Subtyping: axiomatization")
;; (find-zeilbergerthesispage (+ 12 150) "6.2.8 Reconstructing the value/evaluation context restrictions")
;; (find-zeilbergerthesispage (+ 12 151) "6.2.9 The environment semantics and type safety")
;; (find-zeilbergerthesispage (+ 12 152) "6.2.10 Subtyping: the no-counterexamples interpretation")
;; (find-zeilbergerthesispage (+ 12 154) "6.2.11 Some counterexample examples (and counterexamples)")
;; (find-zeilbergerthesispage (+ 12 157) "6.2.12 The (conditional) completeness of the identity coercion interpretation")
;; (find-zeilbergerthesispage (+ 12 160) "6.3 Refining full L")
;; (find-zeilbergerthesispage (+ 12 160) "6.4 Related Work")
;; (find-zeilbergerthesispage (+ 12 163) "7 Conclusion")
;; (find-zeilbergerthesispage (+ 12 165) "Bibliography")
;; (find-zeilbergerthesispage (+ 12 177) "A Agda embedding of L+")
;; (find-zeilbergerthesispage (+ 12 185) "B Twelf embedding of L+")
;; «free-as-in-freedom» (to ".free-as-in-freedom")
;; (find-books "__comp/__comp.el" "free-as-in-freedom")
;; Free as in Freedom (2.0): Richard Stallman and the Free Software Revolution
;; https://www.fsf.org/faif
;; https://static.fsf.org/nosvn/faif-2.0.pdf
(code-pdf-page "faif" "$S/https/static.fsf.org/nosvn/faif-2.0.pdf")
(code-pdf-text "faif" "$S/https/static.fsf.org/nosvn/faif-2.0.pdf" 16)
;; (find-faifpage)
;; (find-faifpage 5 "Contents")
;; (find-faiftext 5 "Contents")
;; (find-faifpage (+ 16 1) "1 For Want of a Printer")
;; (find-faifpage (+ 16 13) "2 2001: A Hacker's Odyssey")
;; (find-faifpage (+ 16 25) "3 A Portrait of the Hacker as a Young Man")
;; (find-faifpage (+ 16 37) "4 Impeach God")
;; (find-faifpage (+ 16 59) "5 Puddle of Freedom")
;; (find-faifpage (+ 16 77) "6 The Emacs Commune")
;; (find-faifpage (+ 16 89) "7 A Stark Moral Choice")
;; (find-faifpage (+ 16 109) "8 St. Ignucius")
;; (find-faifpage (+ 16 123) "9 The GNU General Public License")
;; (find-faifpage (+ 16 145) "10 GNU/Linux")
;; (find-faifpage (+ 16 159) "11 Open Source")
;; (find-faifpage (+ 16 175) "12 A Brief Journey through Hacker Hell")
;; (find-faifpage (+ 16 181) "13 Continuing the Fight")
;; (find-faifpage (+ 16 193) "Epilogue from Sam Williams: Crushing Loneliness")
;; (find-faifpage (+ 16 209) "Appendix A - Hack, Hackers, and Hacking")
;; (find-faifpage (+ 16 217) "Appendix B - GNU Free Documentation License")
;; (find-faiftext)
;; «levy-hackers» (to ".levy-hackers")
;; (find-books "__comp/__comp.el" "levy-hackers")
(code-pdf-page "hackers" "~/books/__comp/levy__hackers_heroes_of_the_computer_revolution.pdf")
(code-pdf-text "hackers" "~/books/__comp/levy__hackers_heroes_of_the_computer_revolution.pdf" 17)
;; (find-hackerspage)
;; (find-hackerspage 6 "Contents")
;; (find-hackerspage 10 "Preface")
;; (find-hackerspage 12 "Who's Who")
;; (find-hackerspage (+ 17 1) "CAMBRIDGE: The Fifties and Sixties")
;; (find-hackerspage (+ 17 3) "Part One. TRUE HACKERS")
;; (find-hackerspage (+ 17 3) "1. The Tech Model Railroad Club")
;; (find-hackerspage (+ 17 27) "2. The Hacker Ethic")
;; (find-hackerspage (+ 17 39) "3. Spacewar")
;; (find-hackerspage (+ 17 61) "4. Greenblatt and Gosper")
;; (find-hackerspage (+ 17 83) "5. The Midnight Computer Wiring Society")
;; (find-hackerspage (+ 17 101) "6. Winners and Losers")
;; (find-hackerspage (+ 17 123) "7. Life")
;; (find-hackerspage (+ 17 149) "Part Two. HARDWARE HACKERS - NORTHERN CALIFORNIA: The Seventies")
;; (find-hackerspage (+ 17 151) "8. Revolt in 2100")
;; (find-hackerspage (+ 17 179) "9. Every Man a God")
;; (find-hackerspage (+ 17 201) "10. The Homebrew Computer Club")
;; (find-hackerspage (+ 17 227) "11. Tiny BASIC")
;; (find-hackerspage (+ 17 249) "12. Woz")
;; (find-hackerspage (+ 17 275) "13. Secrets")
;; (find-hackerspage (+ 17 287) "Part Three. GAME HACKERS - THE SIERRAS: The Eighties")
;; (find-hackerspage (+ 17 289) "14. The Wizard and the Princess")
;; (find-hackerspage (+ 17 313) "15. The Brotherhood")
;; (find-hackerspage (+ 17 325) "16. The Third Generation")
;; (find-hackerspage (+ 17 345) "17. Summer Camp")
;; (find-hackerspage (+ 17 365) "18. Frogger")
;; (find-hackerspage (+ 17 389) "19. Applefest")
;; (find-hackerspage (+ 17 413) "20. Wizard vs. Wizards")
;; (find-hackerspage (+ 17 435) "Part Four. THE LAST OF THE TRUE HACKERS - Cambridge 1983")
;; (find-hackerspage (+ 17 437) "The Last of the True Hackers")
;; (find-hackerspage (+ 17 455) "Afterword: Ten Years After")
;; (find-hackerspage (+ 17 463) "Afterword: 2010")
;; (find-hackerspage (+ 17 479) "Notes")
;; (find-hackerspage (+ 17 485) "Acknowledgments")
;; (find-hackerspage (+ 17 489) "Index")
;; (find-hackerstext "")
;; «stallman» (to ".stallman")
;; Free Software, Free Society: Selected Essays of Richard M. Stallman
;; https://www.gnu.org/philosophy/fsfs/rms-essays.pdf
(code-pdf-page "rmsessays" "$S/https/www.gnu.org/philosophy/fsfs/rms-essays.pdf")
(code-pdf-text "rmsessays" "$S/https/www.gnu.org/philosophy/fsfs/rms-essays.pdf" 6)
;; (find-rmsessayspage)
;; (find-rmsessayspage 3 "Contents")
;; (find-rmsessayspage (+ 6 1) "Editor's Note")
;; (find-rmsessayspage (+ 6 3) "A Note on Software")
;; (find-rmsessayspage (+ 6 7) "Topic Guide")
;; (find-rmsessayspage (+ 6 11) "Introduction")
;; (find-rmsessayspage (+ 6 15) "Section One")
;; (find-rmsessayspage (+ 6 17) "1 The GNU Project")
;; (find-rmsessayspage (+ 6 33) "2 The GNU Manifesto")
;; (find-rmsessayspage (+ 6 43) "3 Free Software Definition")
;; (find-rmsessayspage (+ 6 47) "4 Why Software Should Not Have Owners")
;; (find-rmsessayspage (+ 6 53) "5 What's in a Name?")
;; (find-rmsessayspage (+ 6 57) "6 Why "Free Software" is Better than "Open Source"")
;; (find-rmsessayspage (+ 6 63) "7 Releasing Free Software if You Work at a University")
;; (find-rmsessayspage (+ 6 65) "8 Selling Free Software")
;; (find-rmsessayspage (+ 6 69) "9 Free Software Needs Free Documentation")
;; (find-rmsessayspage (+ 6 71) "10 Free Software Song")
;; (find-rmsessayspage (+ 6 73) "Section Two")
;; (find-rmsessayspage (+ 6 75) "11 The Right to Read")
;; (find-rmsessayspage (+ 6 79) "12 Misinterpreting Copyright--A Series of Errors")
;; (find-rmsessayspage (+ 6 89) "13 Science Must `Push' Copyright Aside")
;; (find-rmsessayspage (+ 6 91) "14 What is Copyleft?")
;; (find-rmsessayspage (+ 6 93) "15 Copyleft: Pragmatic Idealism")
;; (find-rmsessayspage (+ 6 97) "16 The Danger of Software Patents")
;; (find-rmsessayspage (+ 6 115) "Section Three")
;; (find-rmsessayspage (+ 6 117) "17 Can You Trust Your Computer?")
;; (find-rmsessayspage (+ 6 121) "18 Why Software Should Be Free")
;; (find-rmsessayspage (+ 6 128) "Japanese oceanographers")
;; (find-rmsessaystext (+ 6 128) "Japanese oceanographers")
;; (find-rmsessayspage (+ 6 135) "19 Copyright and Globalization in the Age of Computer Networks")
;; (find-rmsessayspage (+ 6 157) "20 Free Software: Freedom and Cooperation")
;; (find-rmsessayspage (+ 6 191) "21 Words to Avoid")
;; (find-rmsessayspage (+ 6 197) "Section Four")
;; (find-rmsessayspage (+ 6 199) "GNU General Public License")
;; (find-rmsessayspage (+ 6 207) "GNU Lesser General Public License")
;; (find-rmsessayspage (+ 6 217) "GNU Free Documentation License")
;; (find-rmsessaystext)
;; «kelty» (to ".kelty")
;; (find-books "__comp/__comp.el" "kelty")
;; EMACS, grep, and UNIX: authorship, invention and translation in software
;; Christopher Kelty, Rice University - March 20, 2006
(code-pdf-page "contextkelty" "~/books/__comp/ConText-Kelty.pdf")
(code-pdf-text "contextkelty" "~/books/__comp/ConText-Kelty.pdf" 1)
;; (find-contextkeltypage)
;; (find-contextkeltypage 1 "Contents")
;; (find-contextkeltypage (+ 1 189) "Index")
;; (find-contextkeltypage (+ 1 10) "was an expression of the way Stallman expected" "others to behave")
;; (find-contextkeltytext (+ 1 10) "was an expression of the way Stallman expected" "others to behave")
;; (find-contextkeltypage (+ 1 14) "emerged from a communal sharing")
;; (find-contextkeltytext (+ 1 14) "emerged from a communal sharing")
;; (find-contextkeltypage (+ 1 25) "If TECO is a programming language")
;; (find-contextkeltytext (+ 1 25) "If TECO is a programming language")
;; (find-contextkeltypage (+ 1 28) "buying software was a less risky option")
;; (find-contextkeltytext (+ 1 28) "buying software was a less risky option")
;; (find-contextkeltypage (+ 1 32) "Part II" "Grep")
;; (find-contextkeltytext (+ 1 32) "Part II" "Grep")
;; (find-contextkeltypage (+ 1 39) "Steven C. Kleene")
;; (find-contextkeltytext (+ 1 39) "Steven C. Kleene")
;; (find-contextkeltypage (+ 1 46) "fixity of printed texts")
;; (find-contextkeltytext (+ 1 46) "fixity of printed texts")
;; (find-contextkeltypage (+ 1 46) "memorized compositions and as spoken")
;; (find-contextkeltytext (+ 1 46) "memorized compositions and as spoken")
;; (find-contextkeltypage (+ 1 48) "transformed")
;; (find-contextkeltytext (+ 1 48) "transformed")
;; (find-contextkeltytext "")
;; (find-angg ".emacs.papers" "lamportlatex")
;; (find-angg ".emacs.papers" "kopkadaly")
;; http://gigapedia.com/items/2926/digital-typography-using-latex
;; Syropoulos/Tsolomitis/Sofroniou: "Digital Typography Using LaTeX"
(code-xpdf "syropoulos" "~/books/__comp/syropoulos__digital_typography_using_latex.pdf")
(code-pdftotext "syropoulos" "~/books/__comp/syropoulos__digital_typography_using_latex.pdf" 16)
;; (ee-page-parameters "syropoulos" 16)
;; (find-syropoulospage 7 "Contents")
;; (find-syropoulospage (+ 16 475) "Index")
;; (find-syropoulostext "\\newenvironment{fminipage}")
;; (find-syropoulostext "")
;; «agda» (to ".agda")
;; (find-books "__comp/__comp.el" "agda")
;; (find-angg ".emacs.papers" "agda")
;; (find-es "agda" "agda-user-manual")
(code-pdf-page "agdausermanual" "~/usrc/agda/doc/user-manual.pdf")
(code-pdf-text "agdausermanual" "~/usrc/agda/doc/user-manual.pdf")
;; (find-agdausermanualpage)
;; (find-agdausermanualtext)
;; (find-agdausermanualpage 3 "CONTENTS")
;; (find-agdausermanualtext 3 "CONTENTS")
;; (find-agdausermanualpage (+ 4 3) "1 Overview")
;; (find-agdausermanualpage (+ 4 5) "2 Getting Started")
;; (find-agdausermanualpage (+ 4 5) "2.1 What is Agda?")
;; (find-agdausermanualpage (+ 4 7) "2.2 Prerequisites")
;; (find-agdausermanualpage (+ 4 7) "2.3 Installation")
;; (find-agdausermanualpage (+ 4 11) "2.4 `Hello world' in Agda")
;; (find-agdausermanualpage (+ 4 12) "2.5 Quick Guide to Editing, Type Checking and Compiling Agda Code")
;; (find-agdausermanualpage (+ 4 14) "2.6 A List of Tutorials")
;; (find-agdausermanualpage (+ 4 17) "3 Language Reference")
;; (find-agdausermanualpage (+ 4 17) "3.1 Abstract definitions")
;; (find-agdausermanualpage (+ 4 20) "3.2 Built-ins")
;; (find-agdausermanualpage (+ 4 32) "3.3 Coinduction")
;; (find-agdausermanualpage (+ 4 34) "3.4 Copatterns")
;; (find-agdausermanualpage (+ 4 38) "3.5 Core language")
;; (find-agdausermanualpage (+ 4 38) "3.6 Cubical")
;; (find-agdausermanualpage (+ 4 51) "3.7 Cumulativity")
;; (find-agdausermanualpage (+ 4 53) "3.8 Data Types")
;; (find-agdausermanualpage (+ 4 56) "3.9 Flat Modality")
;; (find-agdausermanualpage (+ 4 57) "3.10 Foreign Function Interface")
;; (find-agdausermanualpage (+ 4 62) "3.11 Function Definitions")
;; (find-agdausermanualpage (+ 4 66) "3.12 Function Types")
;; (find-agdausermanualpage (+ 4 67) "3.13 Generalization of Declared Variables")
;; (find-agdausermanualpage (+ 4 71) "3.14 Implicit Arguments")
;; (find-agdausermanualpage (+ 4 74) "3.15 Instance Arguments")
;; (find-agdausermanualpage (+ 4 80) "3.16 Irrelevance")
;; (find-agdausermanualpage (+ 4 85) "3.17 Lambda Abstraction")
;; (find-agdausermanualpage (+ 4 86) "3.18 Local Definitions: let and where")
;; (find-agdausermanualpage (+ 4 92) "3.19 Lexical Structure")
;; (find-agdausermanualpage (+ 4 95) "3.20 Literal Overloading")
;; (find-agdausermanualpage (+ 4 97) "3.21 Mixfix Operators")
;; (find-agdausermanualpage (+ 4 100) "3.22 Module System")
;; (find-agdausermanualpage (+ 4 105) "3.23 Mutual Recursion")
;; (find-agdausermanualpage (+ 4 107) "3.24 Pattern Synonyms")
;; (find-agdausermanualpage (+ 4 108) "3.25 Positivity Checking")
;; (find-agdausermanualpage (+ 4 110) "3.26 Postulates")
;; (find-agdausermanualpage (+ 4 111) "3.27 Pragmas")
;; (find-agdausermanualpage (+ 4 114) "3.28 Prop")
;; (find-agdausermanualpage (+ 4 116) "3.29 Record Types")
;; (find-agdausermanualpage (+ 4 124) "3.30 Reflection")
;; (find-agdausermanualpage (+ 4 135) "3.31 Rewriting")
;; (find-agdausermanualpage (+ 4 137) "3.32 Run-time Irrelevance")
;; (find-agdausermanualpage (+ 4 139) "3.33 Safe Agda")
;; (find-agdausermanualpage (+ 4 140) "3.34 Sized Types")
;; (find-agdausermanualpage (+ 4 143) "3.35 Syntactic Sugar")
;; (find-agdausermanualpage (+ 4 148) "3.36 Syntax Declarations")
;; (find-agdausermanualpage (+ 4 148) "3.37 Telescopes")
;; (find-agdausermanualpage (+ 4 149) "3.38 Termination Checking")
;; (find-agdausermanualpage (+ 4 151) "3.39 Universe Levels")
;; (find-agdausermanualpage (+ 4 155) "3.40 With-Abstraction")
;; (find-agdausermanualpage (+ 4 168) "3.41 Without K")
;; (find-agdausermanualpage (+ 4 171) "4 Tools")
;; (find-agdausermanualpage (+ 4 171) "4.1 Automatic Proof Search (Auto)")
;; (find-agdausermanualpage (+ 4 174) "4.2 Command-line options")
;; (find-agdausermanualpage (+ 4 184) "4.3 Compilers")
;; (find-agdausermanualpage (+ 4 186) "4.4 Emacs Mode")
;; (find-agdausermanualpage (+ 4 192) "4.5 Literate Programming")
;; (find-agdausermanualpage (+ 4 194) "4.6 Generating HTML")
;; (find-agdausermanualpage (+ 4 195) "4.7 Generating LaTeX")
;; (find-agdausermanualpage (+ 4 212) "4.8 Library Management")
;; (find-agdausermanualpage (+ 4 215) "4.9 Performance debugging")
;; (find-agdausermanualpage (+ 4 216) "4.10 Search Definitions in Scope")
;; (find-agdausermanualpage (+ 4 217) "5 Contribute")
;; (find-agdausermanualpage (+ 4 217) "5.1 Documentation")
;; (find-agdausermanualpage (+ 4 223) "6 The Agda Team and License")
;; (find-agdausermanualpage (+ 4 225) "7 Indices and tables")
;; (find-agdausermanualpage (+ 4 227) "Bibliography")
;; (find-agdausermanualpage (+ 4 229) "Index")
;; (find-agdausermanualpage (+ 4 13) "To compile a module")
;; (find-agdausermanualtext (+ 4 13) "To compile a module")
;; «agda-dtp» (to ".agda-dtp")
;; (find-books "__comp/__comp.el" "agda-dtp")
;; (find-LATEX "catsem-ab.bib" "bib-Norell08")
;; Norell/Chapman: "Dependently Typed Programming in Agda" (2008)
;; http://www.cse.chalmers.se/~ulfn/papers/afp08/tutorial.pdf
(code-pdf-page "agdadtp" "$S/http/www.cse.chalmers.se/~ulfn/papers/afp08/tutorial.pdf")
(code-pdf-text "agdadtp" "$S/http/www.cse.chalmers.se/~ulfn/papers/afp08/tutorial.pdf")
;; (find-agdadtppage)
;; (find-agdadtptext)
;; (find-agdadtppage 1 "1 Introduction")
;; (find-agdadtptext 1 "1 Introduction")
;; (find-agdadtppage 1 "2 Agda Basics")
;; (find-agdadtptext 1 "2 Agda Basics")
;; (find-agdadtppage 21 "3 Programming Techniques")
;; (find-agdadtptext 21 "3 Programming Techniques")
;; (find-agdadtppage 38 "4.1 Relating Agda types to Haskell types")
;; (find-agdadtptext 38 "4.1 Relating Agda types to Haskell types")
;; «agda-verified» (to ".agda-verified")
;; (find-books "__comp/__comp.el" "agda-verified")
;; https://dl.acm.org/doi/book/10.1145/2841316
;; https://dl.acm.org/doi/pdf/10.1145/2841316
(code-pdf-page "agdaverified" "~/books/__comp/stump__verified_functional_programming_in_agda.pdf")
(code-pdf-text "agdaverified" "~/books/__comp/stump__verified_functional_programming_in_agda.pdf" 25)
;; (find-agdaverifiedpage)
;; (find-agdaverifiedpage 10 "Contents")
;; (find-agdaverifiedtext 10 "Contents")
;; (find-agdaverifiedpage (+ 25 1) "1 Functional Programming with the Booleans")
;; (find-agdaverifiedpage (+ 25 1) "1.1 Declaring the Datatype of Booleans")
;; (find-agdaverifiedpage (+ 25 4) "1.2 First Steps Interacting with Agda")
;; (find-agdaverifiedpage (+ 25 4) "1.3 Syntax Declarations")
;; (find-agdaverifiedpage (+ 25 6) "1.4 Defining Boolean Operations by Pattern Matching: Negation")
;; (find-agdaverifiedpage (+ 25 9) "1.5 Defining Boolean Operations by Pattern Matching: And, Or")
;; (find-agdaverifiedpage (+ 25 11) "1.6 The if-then-else Operation")
;; (find-agdaverifiedpage (+ 25 14) "1.7 Conclusion")
;; (find-agdaverifiedpage (+ 25 14) "Exercises")
;; (find-agdaverifiedpage (+ 25 17) "2 Introduction to Constructive Proof")
;; (find-agdaverifiedpage (+ 25 17) "2.1 A First Theorem about the Booleans")
;; (find-agdaverifiedpage (+ 25 20) "2.2 Universal Theorems")
;; (find-agdaverifiedpage (+ 25 25) "2.3 Another Example, and More On Implicit Arguments")
;; (find-agdaverifiedpage (+ 25 28) "2.4 Theorems with Hypotheses")
;; (find-agdaverifiedpage (+ 25 35) "2.5 Going Deeper: Curry-Howard and Constructivity")
;; (find-agdaverifiedpage (+ 25 38) "2.6 Further Examples")
;; (find-agdaverifiedpage (+ 25 40) "2.7 Conclusion")
;; (find-agdaverifiedpage (+ 25 41) "Exercises")
;; (find-agdaverifiedpage (+ 25 43) "3 Natural Numbers")
;; (find-agdaverifiedpage (+ 25 44) "3.1 Peano Natural Numbers")
;; (find-agdaverifiedpage (+ 25 45) "3.2 Addition")
;; (find-agdaverifiedpage (+ 25 50) "(x : N) x + 0 x")
;; (find-agdaverifiedtext (+ 25 50) "(x : N) x + 0 x")
;; (find-agdaverifiedpage (+ 25 57) "3.3 Multiplication")
;; (find-agdaverifiedpage (+ 25 63) "3.4 Arithmetic Comparison")
;; (find-agdaverifiedpage (+ 25 69) "3.5 Even/Odd and Mutually Recursive Definitions")
;; (find-agdaverifiedpage (+ 25 70) "3.6 Conclusion")
;; (find-agdaverifiedpage (+ 25 70) "Exercises")
;; (find-agdaverifiedpage (+ 25 73) "4 Lists")
;; (find-agdaverifiedpage (+ 25 73) "4.1 The List Datatype and Type Parameters")
;; (find-agdaverifiedpage (+ 25 75) "4.2 Basic Operations on Lists")
;; (find-agdaverifiedpage (+ 25 83) "4.3 Reasoning about List Operations")
;; (find-agdaverifiedpage (+ 25 95) "4.4 Conclusion")
;; (find-agdaverifiedpage (+ 25 96) "Exercises")
;; (find-agdaverifiedpage (+ 25 99) "5 Internal Verification")
;; (find-agdaverifiedpage (+ 25 100) "5.1 Vectors")
;; (find-agdaverifiedpage (+ 25 107) "5.2 Binary Search Trees")
;; (find-agdaverifiedpage (+ 25 115) "5.3 Sigma Types")
;; (find-agdaverifiedtext (+ 25 115) "Sigma Types\n5.3")
;; (find-agdaverifiedpage (+ 25 117) "5.3.1 Why Sigma and Pi?")
;; (find-agdaverifiedtext (+ 25 117) "5.3.1 Why Sigma and Pi?")
;; (find-agdaverifiedpage (+ 25 118) "5.4 Braun Trees")
;; (find-agdaverifiedpage (+ 25 127) "5.5 Discussion: Internal vs. External Verification")
;; (find-agdaverifiedpage (+ 25 129) "5.6 Conclusion")
;; (find-agdaverifiedpage (+ 25 129) "Exercises")
;; (find-agdaverifiedpage (+ 25 131) "6 Type-Level Computation")
;; (find-agdaverifiedpage (+ 25 131) "6.1 Integers")
;; (find-agdaverifiedpage (+ 25 136) "6.2 Formatted Printing")
;; (find-agdaverifiedpage (+ 25 141) "6.3 Proof by Reflection")
;; (find-agdaverifiedpage (+ 25 148) "6.4 Conclusion")
;; (find-agdaverifiedpage (+ 25 149) "Exercises")
;; (find-agdaverifiedpage (+ 25 151) "7 Generating Agda Parsers with gratr")
;; (find-agdaverifiedpage (+ 25 152) "7.1 A Primer on Grammars")
;; (find-agdaverifiedpage (+ 25 158) "7.2 Generating Parsers with gratr")
;; (find-agdaverifiedpage (+ 25 165) "7.3 Conclusion")
;; (find-agdaverifiedpage (+ 25 166) "Exercises")
;; (find-agdaverifiedpage (+ 25 169) "8 A Case Study: Huffman Encoding and Decoding")
;; (find-agdaverifiedpage (+ 25 170) "8.1 The Files")
;; (find-agdaverifiedpage (+ 25 171) "8.2 The Input Formats")
;; (find-agdaverifiedpage (+ 25 171) "8.3 Encoding Textual Input")
;; (find-agdaverifiedpage (+ 25 181) "8.4 Decoding Encoded Text")
;; (find-agdaverifiedpage (+ 25 184) "8.5 Conclusion")
;; (find-agdaverifiedpage (+ 25 185) "Exercises")
;; (find-agdaverifiedpage (+ 25 187) "9 Reasoning About Termination")
;; (find-agdaverifiedpage (+ 25 187) "9.1 Termination Proofs")
;; (find-agdaverifiedpage (+ 25 197) "9.2 Operational Semantics for SK Combinators")
;; (find-agdaverifiedpage (+ 25 213) "9.3 Conclusion")
;; (find-agdaverifiedpage (+ 25 214) "Exercises")
;; (find-agdaverifiedpage (+ 25 215) "10 Intuitionistic Logic and Kripke Semantics")
;; (find-agdaverifiedpage (+ 25 216) "10.1 Positive Propositional Intuitionistic Logic (PPIL)")
;; (find-agdaverifiedpage (+ 25 220) "10.2 Kripke Structures")
;; (find-agdaverifiedpage (+ 25 224) "10.3 Kripke Semantics for PPIL")
;; (find-agdaverifiedpage (+ 25 227) "10.4 Soundness of PPIL")
;; (find-agdaverifiedpage (+ 25 232) "10.5 Completeness")
;; (find-agdaverifiedpage (+ 25 245) "10.6 Conclusion")
;; (find-agdaverifiedpage (+ 25 246) "Exercises")
;; (find-agdaverifiedpage (+ 25 247) "Appendix A Quick Guide to Symbols")
;; (find-agdaverifiedpage (+ 25 249) "Appendix B Commonly Used Emacs Control Commands")
;; (find-agdaverifiedpage (+ 25 251) "Appendix C Some Extra Emacs Definitions")
;; (find-agdaverifiedpage (+ 25 253) "References")
;; (find-agdaverifiedpage (+ 25 257) "Index")
;; (find-agdaverifiedpage (+ 25 259) "Author's Biography")
;; (find-agdaverifiedtext "")
;; «awk» (to ".awk")
;; (find-books "__comp/__comp.el" "awk")
(code-pdf-page "awkbook" "~/books/__comp/aho_kernighan_weinberger__the_awk_programming_language.pdf")
(code-pdf-text "awkbook" "~/books/__comp/aho_kernighan_weinberger__the_awk_programming_language.pdf" 12)
;; (find-awkbookpage 9 "Contents")
;; (find-awkbooktext 9 "Contents")
;; (find-awkbookpage (+ 12 147) "6.6 Recursive-Descent Parsing")
;; (find-awkbooktext (+ 12 147) "6.6 Recursive-Descent Parsing")
;; (find-awkbookpage (+ 12 205) "INDEX")
;; (find-awkbooktext (+ 12 205) "INDEX")
;; (find-awkbooktext "")
;; «bsd-toolbox» (to ".bsd-toolbox")
;; (find-books "__comp/__comp.el" "bsd-toolbox")
(code-pdf-page "bsdtoolbox" "~/books/__comp/bsd_unix_toolbox.pdf")
(code-pdf-text "bsdtoolbox" "~/books/__comp/bsd_unix_toolbox.pdf" 1)
;; (find-bsdtoolboxpage)
;; (find-bsdtoolboxpage 1 "Contents")
;; (find-bsdtoolboxpage (+ 1 189) "Index")
;; (find-bsdtoolboxtext "")
;; «clcrit» (to ".clcrit")
;; Brooks/Gabriel: "A Critique of Common Lisp"
;; https://dreamsongs.com/Files/clcrit.pdf
(code-pdf-page "clcrit" "$S/https/dreamsongs.com/Files/clcrit.pdf")
(code-pdf-text "clcrit" "$S/https/dreamsongs.com/Files/clcrit.pdf")
;; (find-clcritpage)
;; (find-clcrittext)
;; «cli-coreutils» (to ".cli-coreutils")
;; (find-books "__comp/__comp.el" "cli-coreutils")
;; (find-es "unix" "cli-coreutils")
;; https://mail.google.com/mail/ca/u/0/#inbox/FMfcgzGlkPTtRrqdQmgFVKwGjCTsfHhT
;; https://news.ycombinator.com/item?id=28798095 Show HN: “Command line text processing with GNU Coreutils” eBook (learnbyexample.github.io)
(code-pdf-page "clicoreutils" "~/books/__comp/cli_text_processing_coreutils_v1p0.pdf")
(code-pdf-text "clicoreutils" "~/books/__comp/cli_text_processing_coreutils_v1p0.pdf")
;; (find-clicoreutilspage)
;; (find-clicoreutilstext)
;; «clojure» (to ".clojure")
;; (find-es "clojure" "simple-graphics")
(code-xpdf "practclojure" "~/books/__comp/vanderhart_sierra__practical_clojure.pdf")
(code-pdftotext "practclojure" "~/books/__comp/vanderhart_sierra__practical_clojure.pdf")
;; (find-practclojurepage 6 "Contents at a Glance")
;; (find-practclojurepage 7 "Contents")
;; (find-practclojurepage (+ 18 199) "Index")
;; (find-practclojuretext "")
(code-xpdf "progclojure" "~/books/__comp/halloway__programming_clojure.pdf")
(code-pdftotext "progclojure" "~/books/__comp/halloway__programming_clojure.pdf")
;; (find-progclojurepage 7 "Contents")
;; (find-progclojurepage 286 "Index")
;; (find-progclojuretext "")
(code-xpdf "joyofclojure" "~/books/__comp/fogus_houser__the_joy_of_clojure.pdf")
(code-pdftotext "joyofclojure" "~/books/__comp/fogus_houser__the_joy_of_clojure.pdf")
;; (find-joyofclojurepage 8 "Brief Contents")
;; (find-joyofclojurepage 10 "Contents")
;; (find-joyofclojurepage (+ 33 52) "(def frame (java.awt.Frame.))")
;; (find-joyofclojuretext "(def frame (java.awt.Frame.))")
;; (find-joyofclojurepage (+ 33 118) "lazy")
;; (find-joyofclojurepage (+ 33 319) "Index")
;; (find-joyofclojuretext "")
;; «coq» (to ".coq")
;; (find-LATEX "catsem.bib" "bib-Coq")
;; (find-es "coq" "bertot-casteran")
;; http://books.google.com/books?id=m5w5PRj5Nj4C
;; http://gigapedia.com/items/123523/interactive-theorem-proving-and-program-development
(code-djvu "bertotcasteran" "~/books/__comp/bertot_casteran__interactive_theorem_proving_and_program_development.djvu")
(code-djvutotext "bertotcasteran" "~/books/__comp/bertot_casteran__interactive_theorem_proving_and_program_development.djvu")
;; (find-bertotcasteranpage 17 "Contents")
;; (find-bertotcasteranpage 15 "certification of Java applets")
;; (find-bertotcasteranpage (+ 26 1) "1. A Brief Overview")
;; (find-bertotcasteranpage (+ 26 460) "Index")
;; (find-bertotcasterantext)
;; «csound» (to ".csound")
(code-djvu "csoundbook" "~/books/__comp/boulanger__the_csound_book.djvu")
(code-djvutotext "csoundbook" "~/books/__comp/boulanger__the_csound_book.djvu")
;; (find-csoundbookpage 4 "Contents")
;; (find-csoundbookpage (+ 6 727) "Index")
;; (find-csoundbooktext "")
;; (find-csoundbookpage (+ 34 5) "1. Introduction to Sound Design in Csound")
;; (find-csoundbookpage (+ 34 65) "2. Understanding and Using Csound's GEN Routines")
;; (find-csoundbookpage (+ 33 99) "3. What Happens When You Run Csound")
;; (find-csoundbookpage (+ 32 123) "4. Optimizing Your Csound Instruments")
;; (find-csoundbookpage (+ 31 137) "5. Using Csound's Macro Language Extensions")
;; (find-csoundbookpage (+ 29 155) "6. Designing Acoustically Viable Instruments in Csound")
;; (find-csoundbookpage (+ 29 171) "7. Designing Legato Instruments in Csound")
;; (find-csoundbookpage (+ 28 187) "8. Contiguous-Group Wavetable Synthesis of the French Horn in Csound")
;; (find-csoundbookpage (+ 27 197) "9. FM Synthesis and Morphing in Csound: from Percussion to Brass")
;; (find-csoundbookpage (+ 27 207) "10. Modeling \"Classic\" Electronic Keyboards in Csound")
;; (find-csoundbookpage (+ 25 223) "11. A Survey of Classic Synthesis Techniques in Csound")
;; (find-csoundbookpage (+ 25 261) "12. FM Synthesis in Csound")
;; (find-csoundbookpage (+ 24 281) "13. Granular Synthesis in Csound")
;; (find-csoundbookpage (+ 24 293) "14. FOF and FOG Synthesis in Csound")
;; (find-csoundbookpage (+ 24 307) "15. Processing Samples with Csound's FOF Opcode")
;; (find-csoundbookpage (+ 23 321) "16. A Look at Random Numbers, Noise, and Chaos with")
;; (find-csoundbookpage (+ 23 339) "17. Constrained Random Event Generation and Retriggering in Csound")
;; (find-csoundbookpage (+ 23 339) "18. Using Global Csound Instruments for Meta-Parameter")
;; (find-csoundbookpage (+ 23 369) "19. Mathematical Modeling with Csound: From Waveguides to Chaos")
;; (find-csoundbookpage (+ 23 389) "20. An Introduction to Signal Processing with Csound")
;; (find-csoundbookpage (+ 20 437) "21. Understanding Csound's Spectral Data Types")
;; (find-csoundbookpage (+ 18 451) "22. Using Csound to Understand Delay Lines and Their Applications")
;; (find-csoundbookpage (+ 18 467) "23. An Introduction to Reverberation Design with Csound")
;; (find-csoundbookpage (+ 17 483) "24. Implementing the Gardner Reverbs in Csound")
;; (find-csoundbookpage (+ 17 493) "25. Csound-based Auditory Localization")
;; (find-csoundbookpage (+ 15 507) "26. Convolution in Csound: Traditional and Novel Applications")
;; (find-csoundbookpage (+ 15 521) "27. Working with Csound's ADSYN, LPREAD, and LPRESON Opcodes")
;; (find-csoundbookpage (+ 14 541) "28. Csound's Phase Vocoder and Extensions")
;; (find-csoundbookpage (+ 13 563) "29. Efficient Implementation of Analog Waveshaping in Csound")
;; (find-csoundbookpage (+ 12 575) "30. Modeling a Multieffects Processor in Csound")
;; (find-csoundbookpage (+ 10 599) "31. Extending Csound")
;; (find-csoundbookpage (+ 10 613) "32. Adding New Unit Generators to Csound")
;; (find-csoundbookpage (+ 8 637) "1. List of the Csound Book Chapter Instruments")
;; (find-csoundbookpage (+ 8 645) "2. Recommended Reading")
;; (find-csoundbookpage (+ 8 647) "3. Recommended Listening")
;; (find-csoundbookpage (+ 7 653) "4. Sound Intensity and Formants")
;; (find-csoundbookpage (+ 7 657) "5. Pitch Conversion")
;; (find-csoundbookpage (+ 6 663) "6. Csound's Error Messages")
;; (find-csoundbookpage (+ 6 701) "7. Csound Quick Reference")
;; «css» (to ".css")
(code-xpdf "csscookbook" "~/books/__comp/schmitt__css_cookbook_3rd_ed.pdf")
(code-pdftotext "csscookbook" "~/books/__comp/schmitt__css_cookbook_3rd_ed.pdf" 26)
;; (ee-page-parameters "csscookbook" 26)
;; (find-csscookbookpage 9 "Contents")
;; (find-csscookbookpage (+ 26 1) "1. Using HTML Basics")
;; (find-csscookbookpage (+ 26 33) "2. CSS Basics")
;; (find-csscookbookpage (+ 26 35) "2.1 Applying CSS Rules to a Web Page")
;; (find-csscookbookpage (+ 26 38) "2.2 Using Basic Selectors to Apply Styles")
;; (find-csscookbookpage (+ 26 47) "2.3 Applying Child Selectors")
;; (find-csscookbookpage (+ 26 49) "2.4 Applying Adjacent Selectors")
;; (find-csscookbookpage (+ 26 51) "2.5 Applying Attribute Selectors")
;; (find-csscookbookpage (+ 26 53) "2.6 Using Pseudo-Classes")
;; (find-csscookbookpage (+ 26 54) "2.7 Using Pseudo-Elements")
;; (find-csscookbookpage (+ 26 56) "2.8 Determining When to Use Class and ID Selectors")
;; (find-csscookbookpage (+ 26 61) "2.9 Understanding CSS Properties")
;; (find-csscookbookpage (+ 26 62) "2.10 Understanding the Box Model")
;; (find-csscookbookpage (+ 26 70) "2.11 Associating Styles to a Web Page")
;; (find-csscookbookpage (+ 26 73) "2.12 Understanding the Origin")
;; (find-csscookbookpage (+ 26 73) "2.13 Understanding the Sort Order Within CSS")
;; (find-csscookbookpage (+ 26 76) "2.14 Using !important to Override Certain CSS Rules")
;; (find-csscookbookpage (+ 26 77) "2.15 Clarifying Specificity")
;; (find-csscookbookpage (+ 26 79) "2.16 Setting Up Different Types of Stylesheets")
;; (find-csscookbookpage (+ 26 83) "2.17 Adding Comments Within Stylesheets")
;; (find-csscookbookpage (+ 26 84) "2.18 Organizing the Contents of a Stylesheet")
;; (find-csscookbookpage (+ 26 86) "2.19 Working with Shorthand Properties")
;; (find-csscookbookpage (+ 26 88) "2.20 Setting Up an Alternate Stylesheet")
;; (find-csscookbookpage (+ 26 89) "2.21 Using Floats")
;; (find-csscookbookpage (+ 26 92) "2.22 Using Self-Clearing Floated Elements")
;; (find-csscookbookpage (+ 26 95) "2.23 Using Absolute Positioning")
;; (find-csscookbookpage (+ 26 98) "2.24 Using Relative Positioning")
;; (find-csscookbookpage (+ 26 99) "2.25 Using Shackling Positioning")
;; (find-csscookbookpage (+ 26 101) "2.26 Stacking Elements with z-index")
;; (find-csscookbookpage (+ 26 102) "2.27 Validating CSS Rules")
;; (find-csscookbookpage (+ 26 105) "3. Web Typography")
;; (find-csscookbookpage (+ 26 106) "3.1 Specifying Fonts")
;; (find-csscookbookpage (+ 26 109) "3.2 Using Web-Safe Fonts")
;; (find-csscookbookpage (+ 26 112) "3.3 Setting an Ampersand Flourish")
;; (find-csscookbookpage (+ 26 114) "3.4 Embedding Font Files")
;; (find-csscookbookpage (+ 26 118) "3.5 Forcing a Break on Really Long Words")
;; (find-csscookbookpage (+ 26 119) "3.6 Specifying Font Measurements and Sizes")
;; (find-csscookbookpage (+ 26 121) "3.7 Gaining More Cross-Browser Consistency with Font Sizes")
;; (find-csscookbookpage (+ 26 125) "3.8 Setting Hyphens, Em Dashes, and En Dashes")
;; (find-csscookbookpage (+ 26 126) "3.9 Centering Text")
;; (find-csscookbookpage (+ 26 126) "3.10 Setting Text to Be Justified")
;; (find-csscookbookpage (+ 26 128) "3.11 Indicating an Overflow of Text with an Ellipsis")
;; (find-csscookbookpage (+ 26 129) "3.12 Removing Space Between Headings and Paragraphs")
;; (find-csscookbookpage (+ 26 130) "3.13 Setting a Simple Initial Cap")
;; (find-csscookbookpage (+ 26 131) "3.14 Setting a Larger, Centered Initial Cap")
;; (find-csscookbookpage (+ 26 133) "3.15 Setting an Initial Cap with Decoration (Imagery)")
;; (find-csscookbookpage (+ 26 135) "3.16 Creating a Heading with Stylized Text")
;; (find-csscookbookpage (+ 26 137) "3.17 Creating a Heading with Stylized Text and Borders")
;; (find-csscookbookpage (+ 26 139) "3.18 Stylizing a Heading with Text and an Image")
;; (find-csscookbookpage (+ 26 141) "3.19 Creating a Pull Quote with HTML Text")
;; (find-csscookbookpage (+ 26 143) "3.20 Placing a Pull Quote to the Side of a Column")
;; (find-csscookbookpage (+ 26 145) "3.21 Creating a Pull Quote with Borders")
;; (find-csscookbookpage (+ 26 146) "3.22 Creating a Pull Quote with Images")
;; (find-csscookbookpage (+ 26 149) "3.23 Setting the Indent in the First Line of a Paragraph")
;; (find-csscookbookpage (+ 26 150) "3.24 Setting the Indent of Entire Paragraphs")
;; (find-csscookbookpage (+ 26 153) "3.25 Creating a Hanging Indent")
;; (find-csscookbookpage (+ 26 156) "3.26 Styling the First Line of a Paragraph")
;; (find-csscookbookpage (+ 26 158) "3.27 Styling the First Line of a Paragraph with an Image")
;; (find-csscookbookpage (+ 26 159) "3.28 Creating a Highlighted Text Effect")
;; (find-csscookbookpage (+ 26 160) "3.29 Changing the Text Selection Color")
;; (find-csscookbookpage (+ 26 161) "3.30 Changing Line Spacing")
;; (find-csscookbookpage (+ 26 163) "3.31 Adding a Graphic Treatment to HTML Text")
;; (find-csscookbookpage (+ 26 165) "3.32 Placing a Shadow Behind Text")
;; (find-csscookbookpage (+ 26 168) "3.33 Adjusting the Space Between Letters and Words")
;; (find-csscookbookpage (+ 26 171) "3.34 Applying Baseline Rhythm on Web Typography")
;; (find-csscookbookpage (+ 26 173) "3.35 Styling Superscripts and Subscripts Without Messing the Text Baseline")
;; (find-csscookbookpage (+ 26 175) "3.36 Setting Up Multiple Columns of Text")
;; (find-csscookbookpage (+ 26 179) "4. Images")
;; (find-csscookbookpage (+ 26 179) "4.1 Transforming Color Images to Black and White in IE with CSS")
;; (find-csscookbookpage (+ 26 180) "4.2 Setting a Border Around an Image")
;; (find-csscookbookpage (+ 26 182) "4.3 Setting a Rounded Border Around an Image")
;; (find-csscookbookpage (+ 26 184) "4.4 Removing Borders Set on Images by Default in Some Browsers")
;; (find-csscookbookpage (+ 26 186) "4.5 Setting a Background Image")
;; (find-csscookbookpage (+ 26 187) "4.6 Creating a Line of Background Images")
;; (find-csscookbookpage (+ 26 188) "4.7 Positioning a Background Image")
;; (find-csscookbookpage (+ 26 191) "4.8 Using Multiple Background Images on One HTML Element")
;; (find-csscookbookpage (+ 26 194) "4.9 Setting Images on a Border")
;; (find-csscookbookpage (+ 26 197) "4.10 Creating a Stationary Background Image")
;; (find-csscookbookpage (+ 26 199) "4.11 Stretching Images As the Browser Resizes")
;; (find-csscookbookpage (+ 26 202) "4.12 Stretching an Image Across the Entire Browser Window")
;; (find-csscookbookpage (+ 26 203) "4.13 Making Images Scalable")
;; (find-csscookbookpage (+ 26 205) "4.14 Setting How a Browser Renders an Image")
;; (find-csscookbookpage (+ 26 206) "4.15 Rotating Images with CSS")
;; (find-csscookbookpage (+ 26 208) "4.16 Setting Gradients with CSS")
;; (find-csscookbookpage (+ 26 211) "4.17 Creating Transparent PNG Images for IE6 and Later")
;; (find-csscookbookpage (+ 26 212) "4.18 Using Transparent PNG Images with JavaScript")
;; (find-csscookbookpage (+ 26 215) "4.19 Overlaying HTML Text on an Image")
;; (find-csscookbookpage (+ 26 217) "4.20 Replacing HTML Text with an Image")
;; (find-csscookbookpage (+ 26 220) "4.21 Building a Panoramic Image Presentation")
;; (find-csscookbookpage (+ 26 222) "4.22 Combining Different Image Formats")
;; (find-csscookbookpage (+ 26 227) "4.23 Rounding Corners with Fixed-Width Columns")
;; (find-csscookbookpage (+ 26 230) "4.24 Rounding Corners (Sliding Doors Technique)")
;; (find-csscookbookpage (+ 26 235) "4.25 Rounding Corners (Mountaintop Technique)")
;; (find-csscookbookpage (+ 26 239) "4.26 Rounding Corners with JavaScript")
;; (find-csscookbookpage (+ 26 242) "4.27 Setting a Shadow on an Element with CSS")
;; (find-csscookbookpage (+ 26 244) "4.28 Placing a Drop Shadow Behind an Image")
;; (find-csscookbookpage (+ 26 247) "4.29 Placing a Smooth Drop Shadow Behind an Image")
;; (find-csscookbookpage (+ 26 251) "4.30 Making Word Balloons")
;; (find-csscookbookpage (+ 26 254) "4.31 Hindering People from Stealing Your Images")
;; (find-csscookbookpage (+ 26 256) "4.32 Inserting Reflections on Images Automatically")
;; (find-csscookbookpage (+ 26 258) "4.33 Using Image Sprites")
;; (find-csscookbookpage (+ 26 260) "4.34 Clipping Background Images")
;; (find-csscookbookpage (+ 26 262) "4.35 Applying Masks to Images and Borders")
;; (find-csscookbookpage (+ 26 845) "Index")
;; (find-csscookbooktext "")
;; «epigram-ppdt» (to ".epigram-ppdt")
;; https://cs.ru.nl/~freek/courses/tt-2010/tvftl/epigram-notes.pdf
(code-pdf-page "epigramppdt" "$S/https/cs.ru.nl/~freek/courses/tt-2010/tvftl/epigram-notes.pdf")
(code-pdf-text "epigramppdt" "$S/https/cs.ru.nl/~freek/courses/tt-2010/tvftl/epigram-notes.pdf")
;; (find-epigramppdtpage)
;; (find-epigramppdttext)
;; «git» (to ".git")
;; (find-es "git" "books")
;; (find-books "__comp/__comp.el" "git")
;; (find-angg ".emacs" "git-internals")
;; (find-es "cvs" "git")
;; (find-es "git")
;; http://peepcode.com/products/git-internals-pdf
;; (code-xpdf "gitinternals" "~/books/__comp/chacon__git_internals.pdf")
;; (code-pdftotext "gitinternals" "~/books/__comp/chacon__git_internals.pdf" 0)
;; «git-internals» (to ".git-internals")
;; (find-books "__comp/__comp.el" "git-internals")
;; (find-es "git" "git-internals")
;; https://github.com/pluralsight/git-internals-pdf/releases/download/v2.0/peepcode-git.pdf
;; (find-fline "$S/https/github.com/pluralsight/git-internals-pdf/releases/download/v2.0/")
(code-pdf-page "gitinternals" "$S/https/github.com/pluralsight/git-internals-pdf/releases/download/v2.0/peepcode-git.pdf")
(code-pdf-text "gitinternals" "$S/https/github.com/pluralsight/git-internals-pdf/releases/download/v2.0/peepcode-git.pdf")
(code-c-d "gitinternals" "~/usrc/git-internals-pdf-2.0/")
;; (find-gitinternalsfile "")
;; (find-gitinternalspage)
;; (find-gitinternalstext)
;; (find-gitinternalspage 3 "Contents")
;; (find-gitinternalstext 3 "Contents")
;; (find-gitinternalspage 15 "The Blob")
;; (find-gitinternalstext 15 "The Blob")
;; (find-gitinternalspage 16 "blob : a906cb")
;; (find-gitinternalstext 16 "blob : a906cb")
;; (find-gitinternalstext 16 "blob : a906cb" "\f\f")
;; (find-gitinternalspage 17 "The Tree")
;; (find-gitinternalstext 17 "The Tree")
;; (find-gitinternalspage 22 "The Git Data Model")
;; (find-gitinternalstext 22 "The Git Data Model")
;; (find-gitinternalspage 23 "The Model")
;; (find-gitinternalstext 23 "The Model")
;; (find-gitinternalspage 28 "Branching and Merging")
;; (find-gitinternalstext 28 "Branching and Merging")
;; (find-gitinternalspage 30 "called master")
;; (find-gitinternalstext 30 "called master")
;; (find-gitinternalspage 32 "Remotes")
;; (find-gitinternalspage 34 "Rebasing")
;; (find-gitinternalspage 36 "master")
;; (find-gitinternalstext 36 "master")
;; (find-gitinternalspage 39 "cheap branches")
;; (find-gitinternalstext 39 "cheap branches")
;; (find-gitinternalspage 41 "The Treeish")
;; (find-gitinternalspage 42 "Ordinal spec")
;; (find-gitinternalspage 44 "The Git directory")
;; (find-gitinternalspage 48 "Working directory")
;; (find-gitinternalspage 49 "Non-SCM Uses of Git")
;; (find-gitinternalstext 49 "Non-SCM Uses of Git")
;; (find-gitinternalspage 54 "Setting Up Your Profile")
;; (find-gitinternalspage 57 "git status")
;; (find-gitinternalspage 68 "gitk")
;; (find-gitinternalspage 75 "Branching")
;; (find-gitinternalspage 77 "Simple Merging")
;; (find-gitinternalspage 80 "Rebasing")
;; (find-gitinternalspage 86 "Stashing")
;; (find-gitinternalspage 89 "Tagging")
;; (find-gitinternalspage 91 "Exporting Git")
;; (find-gitinternalspage 111 "Commands Overview")
;; (find-gitinternalstext "")
;; «git-progit» (to ".git-progit")
;; (find-books "__comp/__comp.el" "git-progit")
;; (find-angg ".emacs" "pro-git")
(code-pdf "progit" "~/books/__comp/chacon__pro_git.pdf")
(code-pdftotext "progit" "~/books/__comp/chacon__pro_git.pdf" 24)
(code-pdf "progit2" "~/books/__comp/chacon_straub__pro_git.pdf")
(code-pdftotext "progit2" "~/books/__comp/chacon_straub__pro_git.pdf" 1)
;; (find-progitpage)
;; (find-progitpage 7 "Contents at a Glance")
;; (find-progittext 7 "Contents at a Glance")
;; (find-progitpage 9 "Contents")
;; (find-progittext 9 "Contents")
;; (find-progitpage (+ 24 1) "1 Getting Started")
;; (find-progitpage (+ 24 12) "Your Diff Tool")
;; (find-progittext (+ 24 12) "Your Diff Tool")
;; (find-progitpage (+ 24 15) "2 Git Basics")
;; (find-progitpage (+ 24 35) "Working with Remotes")
;; (find-progittext (+ 24 35) "Working with Remotes")
;; (find-progitpage (+ 24 36) "Adding Remote Repositories")
;; (find-progittext (+ 24 36) "Adding Remote Repositories")
;; (find-progitpage (+ 24 38) "Tagging")
;; (find-progittext (+ 24 38) "Tagging")
;; (find-progitpage (+ 24 47) "3 Git Branching")
;; (find-progittext (+ 24 47) "Git Branching")
;; (find-progitpage (+ 24 53) "Basic Branching\n")
;; (find-progittext (+ 24 53) "Basic Branching\n")
;; (find-progitpage (+ 24 69) "Tracking Branches")
;; (find-progittext (+ 24 69) "Tracking Branches")
;; (find-progitpage (+ 24 79) "4 Git on the Server")
;; (find-progitpage (+ 24 107) "5 Distributed Git")
;; (find-progitpage (+ 24 143) "6 Git Tools")
;; (find-progitpage (+ 24 175) "7 Customizing Git")
;; (find-progitpage (+ 24 203) "8 Git and Other Systems")
;; (find-progitpage (+ 24 223) "9 Git Internals.")
;; (find-progitpage (+ 24 259) "Index")
;; (find-progittext "")
;; «git-progit2» (to ".git-progit2")
;; (find-books "__comp/__comp.el" "git-progit2")
;; https://git-scm.com/book/en/v2
;; https://github.com/progit/progit2
;; https://github.com/progit/progit2/releases
;; https://github.com/progit/progit2/releases/download/2.1.277/progit.pdf
;; (find-fline "$S/https/github.com/progit/progit2/releases/download/2.1.109/")
(code-pdf-page "progit2" "$S/https/github.com/progit/progit2/releases/download/2.1.277/progit.pdf")
(code-pdf-text "progit2" "$S/https/github.com/progit/progit2/releases/download/2.1.277/progit.pdf" 6)
;; (find-progit2page)
;; (find-progit2text)
;; (find-progit2page 3 "Table of Contents")
;; (find-progit2text 3 "Table of Contents")
;; (find-progit2page (+ 6 1) "Licence")
;; (find-progit2page (+ 6 2) "Preface by Scott Chacon")
;; (find-progit2page (+ 6 3) "Preface by Ben Straub")
;; (find-progit2page (+ 6 4) "Dedications.")
;; (find-progit2page (+ 6 5) "Contributors.")
;; (find-progit2page (+ 6 7) "Introduction")
;; (find-progit2page (+ 6 9) "Getting Started.")
;; (find-progit2page (+ 6 9) "About Version Control.")
;; (find-progit2page (+ 6 13) "A Short History of Git")
;; (find-progit2page (+ 6 13) "What is Git?")
;; (find-progit2page (+ 6 17) "The Command Line")
;; (find-progit2page (+ 6 17) "Installing Git")
;; (find-progit2page (+ 6 20) "First-Time Git Setup.")
;; (find-progit2page (+ 6 23) "Getting Help.")
;; (find-progit2page (+ 6 24) "Summary")
;; (find-progit2page (+ 6 25) "Git Basics.")
;; (find-progit2page (+ 6 25) "Getting a Git Repository")
;; (find-progit2page (+ 6 27) "Recording Changes to the Repository")
;; (find-progit2page (+ 6 39) "Viewing the Commit History")
;; (find-progit2page (+ 6 46) "Undoing Things.")
;; (find-progit2page (+ 6 50) "Working with Remotes")
;; (find-progit2page (+ 6 56) "Tagging")
;; (find-progit2page (+ 6 62) "Git Aliases")
;; (find-progit2page (+ 6 63) "Summary")
;; (find-progit2page (+ 6 64) "Git Branching.")
;; (find-progit2page (+ 6 64) "Branches in a Nutshell")
;; (find-progit2page (+ 6 71) "Basic Branching and Merging")
;; (find-progit2page (+ 6 74) "Fast-forward")
;; (find-progit2text (+ 6 74) "Fast-forward")
;; (find-progit2page (+ 6 80) "Branch Management")
;; (find-progit2page (+ 6 83) "Branching Workflows")
;; (find-progit2page (+ 6 87) "Remote Branches")
;; (find-progit2page (+ 6 96) "Rebasing")
;; (find-progit2page (+ 6 105) "Summary")
;; (find-progit2page (+ 6 221) "Git Tools")
;; (find-progit2page (+ 6 221) "Revision Selection")
;; (find-progit2page (+ 6 230) "Interactive Staging.")
;; (find-progit2page (+ 6 234) "Stashing and Cleaning")
;; (find-progit2page (+ 6 240) "Signing Your Work.")
;; (find-progit2page (+ 6 244) "Searching")
;; (find-progit2page (+ 6 248) "Rewriting History.")
;; (find-progit2page (+ 6 256) "Reset Demystified")
;; (find-progit2page (+ 6 276) "Advanced Merging.")
;; (find-progit2page (+ 6 295) "Rerere")
;; (find-progit2page (+ 6 301) "Debugging with Git")
;; (find-progit2page (+ 6 304) "Submodules.")
;; (find-progit2page (+ 6 326) "Bundling.")
;; (find-progit2page (+ 6 330) "Replace")
;; (find-progit2page (+ 6 338) "Credential Storage")
;; (find-progit2page (+ 6 343) "Summary")
;; (find-progit2page (+ 6 344) "Customizing Git.")
;; (find-progit2page (+ 6 344) "Git Configuration")
;; (find-progit2page (+ 6 354) "Git Attributes.")
;; (find-progit2page (+ 6 362) "Git Hooks")
;; (find-progit2page (+ 6 365) "An Example Git-Enforced Policy")
;; (find-progit2page (+ 6 375) "Summary")
;; (find-progit2page (+ 6 376) "Git and Other Systems")
;; (find-progit2page (+ 6 376) "Git as a Client")
;; (find-progit2page (+ 6 413) "Migrating to Git")
;; (find-progit2page (+ 6 431) "Summary")
;; (find-progit2page (+ 6 432) "Git Internals.")
;; (find-progit2page (+ 6 432) "Plumbing and Porcelain.")
;; (find-progit2page (+ 6 433) "Git Objects")
;; (find-progit2page (+ 6 443) "Git References.")
;; (find-progit2page (+ 6 447) "Packfiles")
;; (find-progit2page (+ 6 450) "The Refspec")
;; (find-progit2page (+ 6 453) "Transfer Protocols")
;; (find-progit2page (+ 6 458) "Maintenance and Data Recovery")
;; (find-progit2page (+ 6 465) "Environment Variables")
;; (find-progit2page (+ 6 471) "Summary")
;; (find-progit2page (+ 6 498) "Appendix C: Git Commands")
;; (find-progit2page (+ 6 498) "Setup and Config")
;; (find-progit2page (+ 6 500) "Getting and Creating Projects")
;; (find-progit2page (+ 6 501) "Basic Snapshotting.")
;; (find-progit2page (+ 6 503) "Branching and Merging")
;; (find-progit2page (+ 6 505) "Sharing and Updating Projects")
;; (find-progit2page (+ 6 507) "Inspection and Comparison")
;; (find-progit2page (+ 6 508) "Debugging")
;; (find-progit2page (+ 6 509) "Patching")
;; (find-progit2page (+ 6 509) "Email")
;; (find-progit2page (+ 6 511) "External Systems")
;; (find-progit2page (+ 6 511) "Administration")
;; (find-progit2page (+ 6 512) "Plumbing Commands")
;; (find-progit2page (+ 6 513) "Index")
;; «git-fbu» (to ".git-fbu")
;; http://ftp.newartisans.com/pub/git.from.bottom.up.pdf
;; (find-fline "$S/http/ftp.newartisans.com/pub/")
(code-pdf-page "gitfbu" "$S/http/ftp.newartisans.com/pub/git.from.bottom.up.pdf")
(code-pdf-text "gitfbu" "$S/http/ftp.newartisans.com/pub/git.from.bottom.up.pdf")
;; (find-gitfbupage)
;; (find-gitfbutext)
;; (find-gitfbupage 2 "1. License")
;; (find-gitfbupage 3 "2. Introduction")
;; (find-gitfbupage 5 "3. Repository: Directory content tracking")
;; (find-gitfbupage 6 "Introducing the blob")
;; (find-gitfbupage 7 "Blobs are stored in trees")
;; (find-gitfbupage 8 "How trees are made")
;; (find-gitfbupage 10 "e beauty of commits")
;; (find-gitfbupage 12 "A commit by any other name...")
;; (find-gitfbupage 15 "Branching and the power of rebase")
;; (find-gitfbupage 15 "show-branch")
;; (find-gitfbutext 15 "show-branch")
;; (find-gitfbupage 20 "4. The Index: Meet the middle man")
;; (find-gitfbupage 22 "Taking the index farther")
;; (find-gitfbupage 24 "5. To reset, or not to reset")
;; (find-gitfbupage 24 "Doing a mixed reset")
;; (find-gitfbupage 24 "Doing a soft reset")
;; (find-gitfbupage 25 "Doing a hard reset")
;; (find-gitfbupage 27 "6. Last links in the chain: Stashing and the reflog")
;; (find-gitfbupage 30 "7. Conclusion")
;; (find-gitfbupage 31 "8. Further reading")
;; (find-progit2page)
;; (find-progit2page 3 "Contents")
;; (find-progit2page (+ 4 421) "Contents")
;; (find-progit2text "")
;; «haskell» (to ".haskell")
;; (find-books "__comp/__comp.el" "haskell")
;; «haskell-hutton» (to ".haskell-hutton")
;; (find-books "__comp/__comp.el" "haskell-hutton")
;; (find-es "haskell" "hutton-book")
;; http://www.cs.nott.ac.uk/~pszgmh/
;; http://www.cs.nott.ac.uk/~pszgmh/pih.html
;; http://www.cs.nott.ac.uk/~pszgmh/Code.zip
(code-pdf-page "huttonbook" "~/books/__comp/hutton__programming_in_haskell.pdf")
(code-pdf-text "huttonbook" "~/books/__comp/hutton__programming_in_haskell.pdf" 1)
;; (find-huttonbookpage)
;; (find-huttonbookpage 6 "Contents")
;; (find-huttonbooktext 6 "Contents")
;; (find-huttonbookpage 27 "Num a => [a] -> a")
;; (find-huttonbooktext 27 "Num a => [a] -> a")
;; (find-huttonbookpage 32 "2.3 Standard prelude")
;; (find-huttonbooktext 32 "2.3 Standard prelude")
;; (find-huttonbookpage 37 "The layout rule" "where")
;; (find-huttonbooktext 37 "The layout rule" "where")
;; (find-huttonbookpage 44 "3.4 Tuple types")
;; (find-huttonbooktext 44 "3.4 Tuple types")
;; (find-huttonbookpage 49 "3.9 Basic classes")
;; (find-huttonbooktext 49 "3.9 Basic classes")
;; (find-huttonbookpage 52 "Read" "readable types")
;; (find-huttonbooktext 52 "Read" "readable types")
;; (find-huttonbookpage 57 "4.2 Conditional expressions")
;; (find-huttonbooktext 57 "4.2 Conditional expressions")
;; (find-huttonbookpage 58 "4.3 Guarded equations")
;; (find-huttonbooktext 58 "4.3 Guarded equations")
;; (find-huttonbookpage 58 "4.3 Guarded equations")
;; (find-huttonbooktext 58 "4.3 Guarded equations")
;; (find-huttonbookpage 59 "4.4 Pattern matching")
;; (find-huttonbooktext 59 "4.4 Pattern matching")
;; (find-huttonbookpage 63 "4.6 Operator sections")
;; (find-huttonbooktext 63 "4.6 Operator sections")
;; (find-huttonbookpage 67 "5" "List comprehensions")
;; (find-huttonbooktext 67 "5" "List comprehensions")
;; (find-huttonbookpage 68 "5.2 Guards")
;; (find-huttonbooktext 68 "5.2 Guards")
;; (find-huttonbookpage 71 "5.4 String comprehensions")
;; (find-huttonbooktext 71 "5.4 String comprehensions")
;; (find-huttonbookpage 72 "5.5 The Caesar cipher")
;; (find-huttonbooktext 72 "5.5 The Caesar cipher")
;; (find-huttonbookfile "cipher.hs")
;; (find-huttonbookpage 96 "7" "Higher-order functions")
;; (find-huttonbooktext 96 "7" "Higher-order functions")
;; (find-huttonbookpage 106 "7.6 Binary string transmitter")
;; (find-huttonbooktext 106 "7.6 Binary string transmitter")
;; (find-huttonbookfile "transmit.hs")
;; (find-huttonbookpage 110 "7.7 Voting algorithms")
;; (find-huttonbooktext 110 "7.7 Voting algorithms")
;; (find-huttonbookfile "voting.hs")
;; (find-huttonbookpage 116 "8" "Declaring types and classes")
;; (find-huttonbooktext 116 "8" "Declaring types and classes")
;; (find-huttonbookpage 116 "8.1 Type declarations")
;; (find-huttonbooktext 116 "8.1 Type declarations")
;; (find-huttonbookpage 117 "8.2 Data declarations")
;; (find-huttonbooktext 117 "8.2 Data declarations")
;; (find-huttonbookpage 119 "fully evaluated")
;; (find-huttonbooktext 119 "fully evaluated")
;; (find-huttonbookpage 119 "8.3 Newtype declarations")
;; (find-huttonbooktext 119 "8.3 Newtype declarations")
;; (find-huttonbookpage 120 "8.4 Recursive types")
;; (find-huttonbooktext 120 "8.4 Recursive types")
;; (find-huttonbookpage 124 "8.5 Class and instance declarations")
;; (find-huttonbooktext 124 "8.5 Class and instance declarations")
;; (find-huttonbookpage 125 "Derived instances")
;; (find-huttonbooktext 125 "Derived instances")
;; (find-huttonbookpage 126 "8.6 Tautology checker")
;; (find-huttonbooktext 126 "8.6 Tautology checker")
;; (find-huttonbookfile "tautology.hs")
;; (find-huttonbookpage 131 "8.7 Abstract machine")
;; (find-huttonbooktext 131 "8.7 Abstract machine")
;; (find-huttonbookfile "machine.hs")
;; (find-huttonbookpage 136 "9" "The countdown problem")
;; (find-huttonbooktext 136 "9" "The countdown problem")
;; (find-huttonbookfile "countdown.hs")
;; (find-huttonbookfile "countdown2.hs")
;; (find-huttonbookpage 148 "10" "Interactive programming")
;; (find-huttonbooktext 148 "10" "Interactive programming")
;; (find-huttonbookpage 148 "10.1 The problem")
;; (find-huttonbooktext 148 "10.1 The problem")
;; (find-huttonbookpage 149 "10.2 The solution")
;; (find-huttonbooktext 149 "10.2 The solution")
;; (find-huttonbookpage 150 "10.3 Basic actions")
;; (find-huttonbooktext 150 "10.3 Basic actions")
;; (find-huttonbookpage 151 "10.4 Sequencing")
;; (find-huttonbooktext 151 "10.4 Sequencing")
;; (find-huttonbookpage 151 "do notation")
;; (find-huttonbooktext 151 "do notation")
;; (find-huttonbookpage 152 "10.5 Derived primitives")
;; (find-huttonbooktext 152 "10.5 Derived primitives")
;; (find-huttonbookpage 153 "10.6 Hangman")
;; (find-huttonbooktext 153 "10.6 Hangman")
;; (find-huttonbookfile "hangman.hs")
;; (find-huttonbookpage 155 "10.7 Nim")
;; (find-huttonbooktext 155 "10.7 Nim")
;; (find-huttonbookfile "nim.hs")
;; (find-huttonbookpage 159 "10.8 Life")
;; (find-huttonbooktext 159 "10.8 Life")
;; (find-huttonbookfile "life.hs")
;; (find-huttonbookpage 163 "10.9 Chapter remarks")
;; (find-huttonbooktext 163 "10.9 Chapter remarks")
;; (find-huttonbookpage 164 "10.10 Exercises")
;; (find-huttonbooktext 164 "10.10 Exercises")
;; (find-huttonbookpage 166 "11" "Unbeatable tic-tac-toe")
;; (find-huttonbooktext 148 "11" "Unbeatable tic-tac-toe")
;; (find-huttonbookpage 166 "11.1 Introduction")
;; (find-huttonbooktext 166 "11.1 Introduction")
;; (find-huttonbookpage 167 "11.2 Basic declarations")
;; (find-huttonbooktext 167 "11.2 Basic declarations")
;; (find-huttonbookpage 168 "11.3 Grid utilities")
;; (find-huttonbooktext 168 "11.3 Grid utilities")
;; (find-huttonbookpage 169 "11.4 Displaying a grid")
;; (find-huttonbooktext 169 "11.4 Displaying a grid")
;; (find-huttonbookpage 171 "11.5 Making a move")
;; (find-huttonbooktext 171 "11.5 Making a move")
;; (find-huttonbookpage 172 "11.6 Reading a number")
;; (find-huttonbooktext 172 "11.6 Reading a number")
;; (find-huttonbookpage 172 "11.7 Human vs human")
;; (find-huttonbooktext 172 "11.7 Human vs human")
;; (find-huttonbookpage 173 "11.8 Game trees")
;; (find-huttonbooktext 173 "11.8 Game trees")
;; (find-huttonbookpage 175 "11.9 Pruning the tree")
;; (find-huttonbooktext 175 "11.9 Pruning the tree")
;; (find-huttonbookpage 176 "11.10 Minimax algorithm")
;; (find-huttonbooktext 176 "11.10 Minimax algorithm")
;; (find-huttonbookpage 176 "11.10 Minimax algorithm")
;; (find-huttonbooktext 176 "11.10 Minimax algorithm")
;; (find-huttonbookpage 178 "11.11 Human vs computer")
;; (find-huttonbooktext 178 "11.11 Human vs computer")
;; (find-huttonbookfile "tictactoe.hs")
;; (find-huttonbookpage 180 "11.12 Chapter remarks")
;; (find-huttonbooktext 180 "11.12 Chapter remarks")
;; (find-huttonbookpage 180 "11.13 Exercises")
;; (find-huttonbooktext 180 "11.13 Exercises")
;; (find-huttonbookpage 182 "12" "Monads and more")
;; (find-huttonbooktext 182 "12" "Monads and more")
;; (find-huttonbookpage 182 "12.1 Functors")
;; (find-huttonbooktext 182 "12.1 Functors")
;; (find-huttonbookpage 187 "12.2 Applicatives")
;; (find-huttonbooktext 187 "12.2 Applicatives")
;; (find-huttonbookpage 193 "12.3 Monads")
;; (find-huttonbooktext 193 "12.3 Monads")
;; (find-huttonbookpage 196 "m1 >>= \\x1 ->")
;; (find-huttonbooktext 196 "m1 >>= \\x1 ->")
;; (find-huttonbookpage 198 "The state monad")
;; (find-huttonbooktext 198 "The state monad")
;; (find-huttonbookpage 200 "The let mechanism of Haskell")
;; (find-huttonbooktext 200 "The let mechanism of Haskell")
;; (find-huttonbookpage 201 "Relabelling trees")
;; (find-huttonbooktext 201 "Relabelling trees")
;; (find-huttonbookfile "relabel.hs")
;; (find-huttonbookpage 205 "12.4 Chapter remarks")
;; (find-huttonbooktext 205 "12.4 Chapter remarks")
;; (find-huttonbookpage 205 "12.5 Exercises")
;; (find-huttonbooktext 205 "12.5 Exercises")
;; (find-huttonbookpage 208 "13" "Monadic parsing")
;; (find-huttonbooktext 208 "13" "Monadic parsing")
;; (find-huttonbookfile "Parsing.hs")
;; (find-huttonbooktext 148 "13.1" "What is a parser?")
;; (find-huttonbooktext 148 "13.2" "Parsers as functions")
;; (find-huttonbooktext 148 "13.3" "Basic definitions")
;; (find-huttonbooktext 148 "13.4" "Sequencing parsers")
;; (find-huttonbooktext 148 "13.5" "Making choices")
;; (find-huttonbooktext 148 "13.6" "Derived primitives")
;; (find-huttonbooktext 148 "13.7" "Handling spacing")
;; (find-huttonbookpage 218 "13.8 Arithmetic expressions")
;; (find-huttonbooktext 218 "13.8 Arithmetic expressions")
;; (find-huttonbookfile "expression.hs")
;; (find-huttonbookpage 223 "13.9 Calculator")
;; (find-huttonbooktext 223 "13.9 Calculator")
;; (find-huttonbookfile "calculator.hs")
;; (find-huttonbooktext 148 "13.10" "Chapter remarks")
;; (find-huttonbooktext 148 "13.11" "Exercises")
;; (find-huttonbookpage 340 "Index")
;; (find-huttonbooktext "")
;; «haskell-hudak» (to ".haskell-hudak")
;; https://www.haskell.org/tutorial/
;; https://www.haskell.org/tutorial/haskell-98-tutorial.pdf
(code-pdf-page "hudak" "$S/https/www.haskell.org/tutorial/haskell-98-tutorial.pdf")
(code-pdf-text "hudak" "$S/https/www.haskell.org/tutorial/haskell-98-tutorial.pdf")
(code-c-d "hudak" "~/usrc/haskell-98-tutorial-sources/")
;; (find-hudakfile "")
;; (find-hudakpage)
;; (find-hudaktext)
;; (find-hudakpage 1 "1 Introduction")
;; (find-hudaktext 1 "1 Introduction")
;; (find-hudakpage 2 "2 Values, Types, and Other Goodies")
;; (find-hudaktext 2 "2 Values, Types, and Other Goodies")
;; (find-hudakpage 3 "2.1 Polymorphic Types")
;; (find-hudaktext 3 "2.1 Polymorphic Types")
;; (find-hudakpage 5 "2.2 User-Defined Types")
;; (find-hudaktext 5 "2.2 User-De ned Types")
;; (find-hudakpage 21 "5 Type Classes and Overloading")
;; (find-hudaktext 21 "5 Type Classes and Overloading")
;; (find-hudakpage 46 "9.3 Using Monads")
;; (find-hudaktext 46 "9.3 Using Monads")
;; «haskell-rw» (to ".haskell-rw")
;; (find-books "__comp/__comp.el" "haskell-rw")
(code-pdf-page "rwhaskell" "~/books/__comp/osullivan_goerzen_stewart__real_world_haskell.pdf")
(code-pdf-text "rwhaskell" "~/books/__comp/osullivan_goerzen_stewart__real_world_haskell.pdf" 40)
;; (find-rwhaskellpage)
;; (find-rwhaskelltext "")
;; (find-rwhaskellpage (+ 40 655) "Index")
;; (find-rwhaskelltext (+ 40 655) "Index")
;; (find-rwhaskellpage 9 "Table of Contents")
;; (find-rwhaskelltext 9 "Table of Contents")
;; (find-rwhaskellpage (+ 40 1) "1. Getting Started")
;; (find-rwhaskellpage (+ 40 1) "Your Haskell Environment")
;; (find-rwhaskellpage (+ 40 2) "Getting Started with ghci, the Interpreter")
;; (find-rwhaskellpage (+ 40 3) "Basic Interaction: Using ghci as a Calculator")
;; (find-rwhaskellpage (+ 40 3) "Simple Arithmetic")
;; (find-rwhaskellpage (+ 40 4) "An Arithmetic Quirk: Writing Negative Numbers")
;; (find-rwhaskellpage (+ 40 5) "Boolean Logic, Operators, and Value Comparisons")
;; (find-rwhaskellpage (+ 40 7) "Operator Precedence and Associativity")
;; (find-rwhaskellpage (+ 40 8) "Undefined Values, and Introducing Variables")
;; (find-rwhaskellpage (+ 40 8) "Dealing with Precedence and Associativity Rules")
;; (find-rwhaskellpage (+ 40 9) "Command-Line Editing in ghci")
;; (find-rwhaskellpage (+ 40 9) "Lists")
;; (find-rwhaskellpage (+ 40 11) "Operators on Lists")
;; (find-rwhaskellpage (+ 40 11) "Strings and Characters")
;; (find-rwhaskellpage (+ 40 12) "First Steps with Types")
;; (find-rwhaskellpage (+ 40 15) "A Simple Program")
;; (find-rwhaskellpage (+ 40 17) "2. Types and Functions")
;; (find-rwhaskellpage (+ 40 17) "Why Care About Types?")
;; (find-rwhaskellpage (+ 40 18) "Haskell's Type System")
;; (find-rwhaskellpage (+ 40 18) "Strong Types")
;; (find-rwhaskellpage (+ 40 19) "Static Types")
;; (find-rwhaskellpage (+ 40 20) "Type Inference")
;; (find-rwhaskellpage (+ 40 20) "What to Expect from the Type System")
;; (find-rwhaskellpage (+ 40 21) "Some Common Basic Types")
;; (find-rwhaskellpage (+ 40 22) "Function Application")
;; (find-rwhaskellpage (+ 40 23) "Useful Composite Data Types: Lists and Tuples")
;; (find-rwhaskellpage (+ 40 25) "Functions over Lists and Tuples")
;; (find-rwhaskellpage (+ 40 26) "Passing an Expression to a Function")
;; (find-rwhaskellpage (+ 40 27) "Function Types and Purity")
;; (find-rwhaskellpage (+ 40 27) "Haskell Source Files, and Writing Simple Functions")
;; (find-rwhaskellpage (+ 40 28) "Just What Is a Variable, Anyway?")
;; (find-rwhaskellpage (+ 40 29) "Conditional Evaluation")
;; (find-rwhaskellpage (+ 40 32) "Understanding Evaluation by Example")
;; (find-rwhaskellpage (+ 40 32) "Lazy Evaluation")
;; (find-rwhaskellpage (+ 40 33) "A More Involved Example")
;; (find-rwhaskellpage (+ 40 34) "Recursion")
;; (find-rwhaskellpage (+ 40 35) "Ending the Recursion")
;; (find-rwhaskellpage (+ 40 35) "Returning from the Recursion")
;; (find-rwhaskellpage (+ 40 36) "What Have We Learned?")
;; (find-rwhaskellpage (+ 40 36) "Polymorphism in Haskell")
;; (find-rwhaskellpage (+ 40 38) "Reasoning About Polymorphic Functions")
;; (find-rwhaskellpage (+ 40 38) "Further Reading")
;; (find-rwhaskellpage (+ 40 38) "The Type of a Function of More Than One Argument")
;; (find-rwhaskellpage (+ 40 39) "Why the Fuss over Purity?")
;; (find-rwhaskellpage (+ 40 40) "Conclusion")
;; (find-rwhaskellpage (+ 40 41) "3. Defining Types, Streamlining Functions")
;; (find-rwhaskellpage (+ 40 41) "Defining a New Data Type")
;; (find-rwhaskellpage (+ 40 43) "Naming Types and Values")
;; (find-rwhaskellpage (+ 40 43) "Type Synonyms")
;; (find-rwhaskellpage (+ 40 44) "Algebraic Data Types")
;; (find-rwhaskellpage (+ 40 45) "Tuples, Algebraic Data Types, and When to Use Each")
;; (find-rwhaskellpage (+ 40 47) "Analogues to Algebraic Data Types in Other Languages")
;; (find-rwhaskellpage (+ 40 50) "Pattern Matching")
;; (find-rwhaskellpage (+ 40 51) "Construction and Deconstruction")
;; (find-rwhaskellpage (+ 40 52) "Further Adventures")
;; (find-rwhaskellpage (+ 40 53) "Variable Naming in Patterns")
;; (find-rwhaskellpage (+ 40 53) "The Wild Card Pattern")
;; (find-rwhaskellpage (+ 40 54) "Exhaustive Patterns and Wild Cards")
;; (find-rwhaskellpage (+ 40 55) "Record Syntax")
;; (find-rwhaskellpage (+ 40 57) "Parameterized Types")
;; (find-rwhaskellpage (+ 40 58) "Recursive Types")
;; (find-rwhaskellpage (+ 40 60) "Reporting Errors")
;; (find-rwhaskellpage (+ 40 61) "A More Controlled Approach")
;; (find-rwhaskellpage (+ 40 61) "Introducing Local Variables")
;; (find-rwhaskellpage (+ 40 62) "Shadowing")
;; (find-rwhaskellpage (+ 40 63) "The where Clause")
;; (find-rwhaskellpage (+ 40 63) "Local Functions, Global Variables")
;; (find-rwhaskellpage (+ 40 64) "The Offside Rule and Whitespace in an Expression")
;; (find-rwhaskellpage (+ 40 66) "A Note About Tabs Versus Spaces")
;; (find-rwhaskellpage (+ 40 66) "The Offside Rule Is Not Mandatory")
;; (find-rwhaskellpage (+ 40 66) "The case Expression")
;; (find-rwhaskellpage (+ 40 67) "Common Beginner Mistakes with Patterns")
;; (find-rwhaskellpage (+ 40 67) "Incorrectly Matching Against a Variable")
;; (find-rwhaskellpage (+ 40 68) "Incorrectly Trying to Compare for Equality")
;; (find-rwhaskellpage (+ 40 68) "Conditional Evaluation with Guards")
;; (find-rwhaskellpage (+ 40 71) "4. Functional Programming")
;; (find-rwhaskellpage (+ 40 71) "Thinking in Haskell")
;; (find-rwhaskellpage (+ 40 71) "A Simple Command-Line Framework")
;; (find-rwhaskellpage (+ 40 72) "Warming Up: Portably Splitting Lines of Text")
;; (find-rwhaskellpage (+ 40 75) "A Line-Ending Conversion Program")
;; (find-rwhaskellpage (+ 40 76) "Infix Functions")
;; (find-rwhaskellpage (+ 40 77) "Working with Lists")
;; (find-rwhaskellpage (+ 40 78) "Basic List Manipulation")
;; (find-rwhaskellpage (+ 40 79) "Safely and Sanely Working with Crashy Functions")
;; (find-rwhaskellpage (+ 40 79) "Partial and Total Functions")
;; (find-rwhaskellpage (+ 40 80) "More Simple List Manipulations")
;; (find-rwhaskellpage (+ 40 81) "Working with Sublists")
;; (find-rwhaskellpage (+ 40 82) "Searching Lists")
;; (find-rwhaskellpage (+ 40 83) "Working with Several Lists at Once")
;; (find-rwhaskellpage (+ 40 84) "Special String-Handling Functions")
;; (find-rwhaskellpage (+ 40 84) "How to Think About Loops")
;; (find-rwhaskellpage (+ 40 85) "Explicit Recursion")
;; (find-rwhaskellpage (+ 40 87) "Transforming Every Piece of Input")
;; (find-rwhaskellpage (+ 40 88) "Mapping over a List")
;; (find-rwhaskellpage (+ 40 90) "Selecting Pieces of Input")
;; (find-rwhaskellpage (+ 40 90) "Computing One Answer over a Collection")
;; (find-rwhaskellpage (+ 40 92) "The Left Fold")
;; (find-rwhaskellpage (+ 40 93) "Why Use Folds, Maps, and Filters?")
;; (find-rwhaskellpage (+ 40 94) "Folding from the Right")
;; (find-rwhaskellpage (+ 40 96) "Left Folds, Laziness, and Space Leaks")
;; (find-rwhaskellpage (+ 40 99) "Further Reading")
;; (find-rwhaskellpage (+ 40 99) "Anonymous (lambda) Functions")
;; (find-rwhaskellpage (+ 40 100) "Partial Function Application and Currying")
;; (find-rwhaskellpage (+ 40 102) "Sections")
;; (find-rwhaskellpage (+ 40 103) "As-patterns")
;; (find-rwhaskellpage (+ 40 104) "Code Reuse Through Composition")
;; (find-rwhaskellpage (+ 40 107) "Use Your Head Wisely")
;; (find-rwhaskellpage (+ 40 107) "Tips for Writing Readable Code")
;; (find-rwhaskellpage (+ 40 108) "Space Leaks and Strict Evaluation")
;; (find-rwhaskellpage (+ 40 108) "Avoiding Space Leaks with seq")
;; (find-rwhaskellpage (+ 40 109) "Learning to Use seq")
;; (find-rwhaskellpage (+ 40 111) "5. Writing a Library: Working with JSON Data")
;; (find-rwhaskellpage (+ 40 111) "A Whirlwind Tour of JSON")
;; (find-rwhaskellpage (+ 40 111) "Representing JSON Data in Haskell")
;; (find-rwhaskellpage (+ 40 113) "The Anatomy of a Haskell Module")
;; (find-rwhaskellpage (+ 40 114) "Compiling Haskell Source")
;; (find-rwhaskellpage (+ 40 114) "Generating a Haskell Program and Importing Modules")
;; (find-rwhaskellpage (+ 40 115) "Printing JSON Data")
;; (find-rwhaskellpage (+ 40 117) "Type Inference Is a Double-Edged Sword")
;; (find-rwhaskellpage (+ 40 118) "A More General Look at Rendering")
;; (find-rwhaskellpage (+ 40 119) "Developing Haskell Code Without Going Nuts")
;; (find-rwhaskellpage (+ 40 120) "Pretty Printing a String")
;; (find-rwhaskellpage (+ 40 122) "Arrays and Objects, and the Module Header")
;; (find-rwhaskellpage (+ 40 123) "Writing a Module Header")
;; (find-rwhaskellpage (+ 40 124) "Fleshing Out the Pretty-Printing Library")
;; (find-rwhaskellpage (+ 40 127) "Compact Rendering")
;; (find-rwhaskellpage (+ 40 128) "True Pretty Printing")
;; (find-rwhaskellpage (+ 40 129) "Following the Pretty Printer")
;; (find-rwhaskellpage (+ 40 131) "Creating a Package")
;; (find-rwhaskellpage (+ 40 131) "Writing a Package Description")
;; (find-rwhaskellpage (+ 40 133) "GHC's Package Manager")
;; (find-rwhaskellpage (+ 40 133) "Setting Up, Building, and Installing")
;; (find-rwhaskellpage (+ 40 134) "Practical Pointers and Further Reading")
;; (find-rwhaskellpage (+ 40 135) "6. Using Typeclasses")
;; (find-rwhaskellpage (+ 40 135) "The Need for Typeclasses")
;; (find-rwhaskellpage (+ 40 136) "What Are Typeclasses?")
;; (find-rwhaskellpage (+ 40 139) "Declaring Typeclass Instances")
;; (find-rwhaskellpage (+ 40 139) "Important Built-in Typeclasses")
;; (find-rwhaskellpage (+ 40 139) "Show")
;; (find-rwhaskellpage (+ 40 141) "Read")
;; (find-rwhaskellpage (+ 40 143) "Serialization with read and show")
;; (find-rwhaskellpage (+ 40 144) "Numeric Types")
;; (find-rwhaskellpage (+ 40 148) "Equality, Ordering, and Comparisons")
;; (find-rwhaskellpage (+ 40 148) "Automatic Derivation")
;; (find-rwhaskellpage (+ 40 149) "Typeclasses at Work: Making JSON Easier to Use")
;; (find-rwhaskellpage (+ 40 151) "More Helpful Errors")
;; (find-rwhaskellpage (+ 40 151) "Making an Instance with a Type Synonym")
;; (find-rwhaskellpage (+ 40 152) "Living in an Open World")
;; (find-rwhaskellpage (+ 40 153) "When Do Overlapping Instances Cause Problems?")
;; (find-rwhaskellpage (+ 40 154) "Relaxing Some Restrictions on Typeclasses")
;; (find-rwhaskellpage (+ 40 155) "How Does Show Work for Strings?")
;; (find-rwhaskellpage (+ 40 155) "How to Give a Type a New Identity")
;; (find-rwhaskellpage (+ 40 157) "Differences Between Data and Newtype Declarations")
;; (find-rwhaskellpage (+ 40 158) "Summary: The Three Ways of Naming Types")
;; (find-rwhaskellpage (+ 40 159) "JSON Typeclasses Without Overlapping Instances")
;; (find-rwhaskellpage (+ 40 162) "The Dreaded Monomorphism Restriction")
;; (find-rwhaskellpage (+ 40 163) "Conclusion")
;; (find-rwhaskellpage (+ 40 165) "7. I/O")
;; (find-rwhaskellpage (+ 40 165) "Classic I/O in Haskell")
;; (find-rwhaskellpage (+ 40 168) "Pure Versus I/O")
;; (find-rwhaskellpage (+ 40 169) "Why Purity Matters")
;; (find-rwhaskellpage (+ 40 169) "Working with Files and Handles")
;; (find-rwhaskellpage (+ 40 171) "More on openFile")
;; (find-rwhaskellpage (+ 40 172) "Closing Handles")
;; (find-rwhaskellpage (+ 40 172) "Seek and Tell")
;; (find-rwhaskellpage (+ 40 173) "Standard Input, Output, and Error")
;; (find-rwhaskellpage (+ 40 174) "Deleting and Renaming Files")
;; (find-rwhaskellpage (+ 40 174) "Temporary Files")
;; (find-rwhaskellpage (+ 40 175) "Extended Example: Functional I/O and Temporary Files")
;; (find-rwhaskellpage (+ 40 178) "Lazy I/O")
;; (find-rwhaskellpage (+ 40 178) "hGetContents")
;; (find-rwhaskellpage (+ 40 180) "readFile and writeFile")
;; (find-rwhaskellpage (+ 40 181) "A Word on Lazy Output")
;; (find-rwhaskellpage (+ 40 181) "interact")
;; (find-rwhaskellpage (+ 40 183) "The IO Monad")
;; (find-rwhaskellpage (+ 40 183) "Actions")
;; (find-rwhaskellpage (+ 40 186) "Sequencing")
;; (find-rwhaskellpage (+ 40 187) "The True Nature of Return")
;; (find-rwhaskellpage (+ 40 188) "Is Haskell Really Imperative?")
;; (find-rwhaskellpage (+ 40 188) "Side Effects with Lazy I/O")
;; (find-rwhaskellpage (+ 40 189) "Buffering")
;; (find-rwhaskellpage (+ 40 189) "Buffering Modes")
;; (find-rwhaskellpage (+ 40 190) "Flushing The Buffer")
;; (find-rwhaskellpage (+ 40 190) "Reading Command-Line Arguments")
;; (find-rwhaskellpage (+ 40 191) "Environment Variables")
;; (find-rwhaskellpage (+ 40 193) "8. Efficient File Processing, Regular Expressions, and Filename Matching")
;; (find-rwhaskellpage (+ 40 193) "Efficient File Processing")
;; (find-rwhaskellpage (+ 40 194) "Binary I/O and Qualified Imports")
;; (find-rwhaskellpage (+ 40 195) "Text I/O")
;; (find-rwhaskellpage (+ 40 197) "Filename Matching")
;; (find-rwhaskellpage (+ 40 198) "Regular Expressions in Haskell")
;; (find-rwhaskellpage (+ 40 198) "The Many Types of Result")
;; (find-rwhaskellpage (+ 40 200) "More About Regular Expressions")
;; (find-rwhaskellpage (+ 40 200) "Mixing and Matching String Types")
;; (find-rwhaskellpage (+ 40 201) "Other Things You Should Know")
;; (find-rwhaskellpage (+ 40 202) "Translating a glob Pattern into a Regular Expression")
;; (find-rwhaskellpage (+ 40 205) "An important Aside: Writing Lazy Functions")
;; (find-rwhaskellpage (+ 40 206) "Making Use of Our Pattern Matcher")
;; (find-rwhaskellpage (+ 40 210) "Handling Errors Through API Design")
;; (find-rwhaskellpage (+ 40 211) "Putting Our Code to Work")
;; (find-rwhaskellpage (+ 40 213) "9. I/O Case Study: A Library for Searching the Filesystem")
;; (find-rwhaskellpage (+ 40 213) "The find Command")
;; (find-rwhaskellpage (+ 40 213) "Starting Simple: Recursively Listing a Directory")
;; (find-rwhaskellpage (+ 40 214) "Revisiting Anonymous and Named Functions")
;; (find-rwhaskellpage (+ 40 215) "Why Provide Both mapM and forM?")
;; (find-rwhaskellpage (+ 40 215) "A Naive Finding Function")
;; (find-rwhaskellpage (+ 40 217) "Predicates: From Poverty to Riches, While Remaining Pure")
;; (find-rwhaskellpage (+ 40 219) "Sizing a File Safely")
;; (find-rwhaskellpage (+ 40 221) "The Acquire-Use-Release Cycle")
;; (find-rwhaskellpage (+ 40 221) "A Domain-Specific Language for Predicates")
;; (find-rwhaskellpage (+ 40 223) "Avoiding Boilerplate with Lifting")
;; (find-rwhaskellpage (+ 40 224) "Gluing Predicates Together")
;; (find-rwhaskellpage (+ 40 225) "Defining and Using New Operators")
;; (find-rwhaskellpage (+ 40 226) "Controlling Traversal")
;; (find-rwhaskellpage (+ 40 228) "Density, Readability, and the Learning Process")
;; (find-rwhaskellpage (+ 40 229) "Another Way of Looking at Traversal")
;; (find-rwhaskellpage (+ 40 232) "Useful Coding Guidelines")
;; (find-rwhaskellpage (+ 40 233) "Common Layout Styles")
;; (find-rwhaskellpage (+ 40 235) "10. Code Case Study: Parsing a Binary Data Format")
;; (find-rwhaskellpage (+ 40 235) "Grayscale Files")
;; (find-rwhaskellpage (+ 40 236) "Parsing a Raw PGM File")
;; (find-rwhaskellpage (+ 40 238) "Getting Rid of Boilerplate Code")
;; (find-rwhaskellpage (+ 40 239) "Implicit State")
;; (find-rwhaskellpage (+ 40 240) "The Identity Parser")
;; (find-rwhaskellpage (+ 40 241) "Record Syntax, Updates, and Pattern Matching")
;; (find-rwhaskellpage (+ 40 242) "A More Interesting Parser")
;; (find-rwhaskellpage (+ 40 242) "Obtaining and Modifying the Parse State")
;; (find-rwhaskellpage (+ 40 243) "Reporting Parse Errors")
;; (find-rwhaskellpage (+ 40 243) "Chaining Parsers Together")
;; (find-rwhaskellpage (+ 40 244) "Introducing Functors")
;; (find-rwhaskellpage (+ 40 247) "Constraints on Type Definitions Are Bad")
;; (find-rwhaskellpage (+ 40 248) "Infix Use of fmap")
;; (find-rwhaskellpage (+ 40 248) "Flexible Instances")
;; (find-rwhaskellpage (+ 40 249) "Thinking More About Functors")
;; (find-rwhaskellpage (+ 40 250) "Writing a Functor Instance for Parse")
;; (find-rwhaskellpage (+ 40 251) "Using Functors for Parsing")
;; (find-rwhaskellpage (+ 40 252) "Rewriting Our PGM Parser")
;; (find-rwhaskellpage (+ 40 254) "Future Directions")
;; (find-rwhaskellpage (+ 40 255) "11. Testing and Quality Assurance")
;; (find-rwhaskellpage (+ 40 256) "QuickCheck: Type-Based Testing")
;; (find-rwhaskellpage (+ 40 257) "Testing for Properties")
;; (find-rwhaskellpage (+ 40 259) "Testing Against a Model")
;; (find-rwhaskellpage (+ 40 259) "Testing Case Study: Specifying a Pretty Printer")
;; (find-rwhaskellpage (+ 40 259) "Generating Test Data")
;; (find-rwhaskellpage (+ 40 262) "Testing Document Construction")
;; (find-rwhaskellpage (+ 40 263) "Using Lists as a Model")
;; (find-rwhaskellpage (+ 40 264) "Putting It All Together")
;; (find-rwhaskellpage (+ 40 265) "Measuring Test Coverage with HPC")
;; (find-rwhaskellpage (+ 40 269) "12. Barcode Recognition")
;; (find-rwhaskellpage (+ 40 269) "A Little Bit About Barcodes")
;; (find-rwhaskellpage (+ 40 270) "EAN-13 Encoding")
;; (find-rwhaskellpage (+ 40 270) "Introducing Arrays")
;; (find-rwhaskellpage (+ 40 273) "Arrays and Laziness")
;; (find-rwhaskellpage (+ 40 273) "Folding over Arrays")
;; (find-rwhaskellpage (+ 40 274) "Modifying Array Elements")
;; (find-rwhaskellpage (+ 40 275) "Encoding an EAN-13 Barcode")
;; (find-rwhaskellpage (+ 40 275) "Constraints on Our Decoder")
;; (find-rwhaskellpage (+ 40 276) "Divide and Conquer")
;; (find-rwhaskellpage (+ 40 278) "Turning a Color Image into Something Tractable")
;; (find-rwhaskellpage (+ 40 278) "Parsing a Color Image")
;; (find-rwhaskellpage (+ 40 279) "Grayscale Conversion")
;; (find-rwhaskellpage (+ 40 279) "Grayscale to Binary and Type Safety")
;; (find-rwhaskellpage (+ 40 280) "What Have We Done to Our Image?")
;; (find-rwhaskellpage (+ 40 282) "Finding Matching Digits")
;; (find-rwhaskellpage (+ 40 282) "Run Length Encoding")
;; (find-rwhaskellpage (+ 40 283) "Scaling Run Lengths, and Finding Approximate Matches")
;; (find-rwhaskellpage (+ 40 284) "List Comprehensions")
;; (find-rwhaskellpage (+ 40 285) "Remembering a Match's Parity")
;; (find-rwhaskellpage (+ 40 287) "Chunking a List")
;; (find-rwhaskellpage (+ 40 287) "Generating a List of Candidate Digits")
;; (find-rwhaskellpage (+ 40 288) "Life Without Arrays or Hash Tables")
;; (find-rwhaskellpage (+ 40 288) "A Forest of Solutions")
;; (find-rwhaskellpage (+ 40 289) "A Brief Introduction to Maps")
;; (find-rwhaskellpage (+ 40 292) "Further Reading")
;; (find-rwhaskellpage (+ 40 292) "Turning Digit Soup into an Answer")
;; (find-rwhaskellpage (+ 40 292) "Solving for Check Digits in Parallel")
;; (find-rwhaskellpage (+ 40 294) "Completing the Solution Map with the First Digit")
;; (find-rwhaskellpage (+ 40 295) "Finding the Correct Sequence")
;; (find-rwhaskellpage (+ 40 295) "Working with Row Data")
;; (find-rwhaskellpage (+ 40 296) "Pulling It All Together")
;; (find-rwhaskellpage (+ 40 297) "A Few Comments on Development Style")
;; (find-rwhaskellpage (+ 40 299) "13. Data Structures")
;; (find-rwhaskellpage (+ 40 299) "Association Lists")
;; (find-rwhaskellpage (+ 40 301) "Maps")
;; (find-rwhaskellpage (+ 40 303) "Functions Are Data, Too")
;; (find-rwhaskellpage (+ 40 304) "Extended Example: /etc/passwd")
;; (find-rwhaskellpage (+ 40 307) "Extended Example: Numeric Types")
;; (find-rwhaskellpage (+ 40 309) "First Steps")
;; (find-rwhaskellpage (+ 40 311) "Completed Code")
;; (find-rwhaskellpage (+ 40 317) "Taking Advantage of Functions as Data")
;; (find-rwhaskellpage (+ 40 318) "Turning Difference Lists into a Proper Library")
;; (find-rwhaskellpage (+ 40 320) "Lists, Difference Lists, and Monoids")
;; (find-rwhaskellpage (+ 40 322) "General-Purpose Sequences")
;; (find-rwhaskellpage (+ 40 325) "14. Monads")
;; (find-rwhaskellpage (+ 40 325) "Revisiting Earlier Code Examples")
;; (find-rwhaskellpage (+ 40 325) "Maybe Chaining")
;; (find-rwhaskellpage (+ 40 326) "Implicit State")
;; (find-rwhaskellpage (+ 40 327) "Looking for Shared Patterns")
;; (find-rwhaskellpage (+ 40 329) "The Monad Typeclass")
;; (find-rwhaskellpage (+ 40 330) "And Now, a Jargon Moment")
;; (find-rwhaskellpage (+ 40 331) "Using a New Monad: Show Your Work!")
;; (find-rwhaskellpage (+ 40 331) "Information Hiding")
;; (find-rwhaskellpage (+ 40 332) "Controlled Escape")
;; (find-rwhaskellpage (+ 40 332) "Leaving a Trace")
;; (find-rwhaskellpage (+ 40 333) "Using the Logger Monad")
;; (find-rwhaskellpage (+ 40 334) "Mixing Pure and Monadic Code")
;; (find-rwhaskellpage (+ 40 336) "Putting a Few Misconceptions to Rest")
;; (find-rwhaskellpage (+ 40 336) "Building the Logger Monad")
;; (find-rwhaskellpage (+ 40 337) "Sequential Logging, Not Sequential Evaluation")
;; (find-rwhaskellpage (+ 40 337) "The Writer Monad")
;; (find-rwhaskellpage (+ 40 338) "The Maybe Monad")
;; (find-rwhaskellpage (+ 40 338) "Executing the Maybe Monad")
;; (find-rwhaskellpage (+ 40 338) "Maybe at Work, and Good API Design")
;; (find-rwhaskellpage (+ 40 340) "The List Monad")
;; (find-rwhaskellpage (+ 40 342) "Understanding the List Monad")
;; (find-rwhaskellpage (+ 40 343) "Putting the List Monad to Work")
;; (find-rwhaskellpage (+ 40 344) "Desugaring of do Blocks")
;; (find-rwhaskellpage (+ 40 345) "Monads as a Programmable Semicolon")
;; (find-rwhaskellpage (+ 40 346) "Why Go Sugar-Free?")
;; (find-rwhaskellpage (+ 40 346) "The State Monad")
;; (find-rwhaskellpage (+ 40 347) "Almost a State Monad")
;; (find-rwhaskellpage (+ 40 348) "Reading and Modifying the State")
;; (find-rwhaskellpage (+ 40 348) "Will the Real State Monad Please Stand Up?")
;; (find-rwhaskellpage (+ 40 349) "Using the State Monad: Generating Random Values")
;; (find-rwhaskellpage (+ 40 350) "A First Attempt at Purity")
;; (find-rwhaskellpage (+ 40 351) "Random Values in the State Monad")
;; (find-rwhaskellpage (+ 40 352) "Running the State Monad")
;; (find-rwhaskellpage (+ 40 352) "What About a Bit More State?")
;; (find-rwhaskellpage (+ 40 354) "Monads and Functors")
;; (find-rwhaskellpage (+ 40 354) "Another Way of Looking at Monads")
;; (find-rwhaskellpage (+ 40 355) "The Monad Laws and Good Coding Style")
;; (find-rwhaskellpage (+ 40 359) "15. Programming with Monads")
;; (find-rwhaskellpage (+ 40 359) "Golfing Practice: Association Lists")
;; (find-rwhaskellpage (+ 40 360) "Generalized Lifting")
;; (find-rwhaskellpage (+ 40 362) "Looking for Alternatives")
;; (find-rwhaskellpage (+ 40 364) "The Name mplus Does Not Imply Addition")
;; (find-rwhaskellpage (+ 40 364) "Rules for Working with MonadPlus")
;; (find-rwhaskellpage (+ 40 364) "Failing Safely with MonadPlus")
;; (find-rwhaskellpage (+ 40 365) "Adventures in Hiding the Plumbing")
;; (find-rwhaskellpage (+ 40 368) "Supplying Random Numbers")
;; (find-rwhaskellpage (+ 40 369) "Another Round of Golf")
;; (find-rwhaskellpage (+ 40 369) "Separating Interface from Implementation")
;; (find-rwhaskellpage (+ 40 370) "Multiparameter Typeclasses")
;; (find-rwhaskellpage (+ 40 370) "Functional Dependencies")
;; (find-rwhaskellpage (+ 40 371) "Rounding Out Our Module")
;; (find-rwhaskellpage (+ 40 372) "Programming to a Monad's Interface")
;; (find-rwhaskellpage (+ 40 373) "The Reader Monad")
;; (find-rwhaskellpage (+ 40 374) "A Return to Automated Deriving")
;; (find-rwhaskellpage (+ 40 375) "Hiding the IO Monad")
;; (find-rwhaskellpage (+ 40 376) "Using a newtype")
;; (find-rwhaskellpage (+ 40 377) "Designing for Unexpected Uses")
;; (find-rwhaskellpage (+ 40 378) "Using Typeclasses")
;; (find-rwhaskellpage (+ 40 379) "Isolation and Testing")
;; (find-rwhaskellpage (+ 40 380) "The Writer Monad and Lists")
;; (find-rwhaskellpage (+ 40 381) "Arbitrary I/O Revisited")
;; (find-rwhaskellpage (+ 40 383) "16. Using Parsec")
;; (find-rwhaskellpage (+ 40 383) "First Steps with Parsec: Simple CSV Parsing")
;; (find-rwhaskellpage (+ 40 386) "The sepBy and endBy Combinators")
;; (find-rwhaskellpage (+ 40 387) "Choices and Errors")
;; (find-rwhaskellpage (+ 40 389) "Lookahead")
;; (find-rwhaskellpage (+ 40 390) "Error Handling")
;; (find-rwhaskellpage (+ 40 391) "Extended Example: Full CSV Parser")
;; (find-rwhaskellpage (+ 40 393) "Parsec and MonadPlus")
;; (find-rwhaskellpage (+ 40 393) "Parsing a URL-Encoded Query String")
;; (find-rwhaskellpage (+ 40 395) "Supplanting Regular Expressions for Casual Parsing")
;; (find-rwhaskellpage (+ 40 395) "Parsing Without Variables")
;; (find-rwhaskellpage (+ 40 395) "Applicative Functors for Parsing")
;; (find-rwhaskellpage (+ 40 396) "Applicative Parsing by Example")
;; (find-rwhaskellpage (+ 40 398) "Parsing JSON Data")
;; (find-rwhaskellpage (+ 40 401) "Parsing a HTTP Request")
;; (find-rwhaskellpage (+ 40 402) "Backtracking and Its Discontents")
;; (find-rwhaskellpage (+ 40 402) "Parsing Headers")
;; (find-rwhaskellpage (+ 40 405) "17. Interfacing with C: The FFI")
;; (find-rwhaskellpage (+ 40 406) "Foreign Language Bindings: The Basics")
;; (find-rwhaskellpage (+ 40 407) "Be Careful of Side Effects")
;; (find-rwhaskellpage (+ 40 408) "A High-Level Wrapper")
;; (find-rwhaskellpage (+ 40 409) "Regular Expressions for Haskell: A Binding for PCRE")
;; (find-rwhaskellpage (+ 40 410) "Simple Tasks: Using the C Preprocessor")
;; (find-rwhaskellpage (+ 40 411) "Binding Haskell to C with hsc2hs")
;; (find-rwhaskellpage (+ 40 411) "Adding Type Safety to PCRE")
;; (find-rwhaskellpage (+ 40 412) "Binding to Constants")
;; (find-rwhaskellpage (+ 40 413) "Automating the Binding")
;; (find-rwhaskellpage (+ 40 414) "Passing String Data Between Haskell and C")
;; (find-rwhaskellpage (+ 40 416) "Typed Pointers")
;; (find-rwhaskellpage (+ 40 417) "Memory Management: Let the Garbage Collector Do the Work")
;; (find-rwhaskellpage (+ 40 418) "A High-Level Interface: Marshaling Data")
;; (find-rwhaskellpage (+ 40 419) "Marshaling ByteStrings")
;; (find-rwhaskellpage (+ 40 419) "Allocating Local C Data: The Storable Class")
;; (find-rwhaskellpage (+ 40 420) "Putting It All Together")
;; (find-rwhaskellpage (+ 40 422) "Matching on Strings")
;; (find-rwhaskellpage (+ 40 423) "Extracting Information About the Pattern")
;; (find-rwhaskellpage (+ 40 424) "Pattern Matching with Substrings")
;; (find-rwhaskellpage (+ 40 426) "The Real Deal: Compiling and Matching Regular Expressions")
;; (find-rwhaskellpage (+ 40 429) "18. Monad Transformers")
;; (find-rwhaskellpage (+ 40 429) "Motivation: Boilerplate Avoidance")
;; (find-rwhaskellpage (+ 40 430) "A Simple Monad Transformer Example")
;; (find-rwhaskellpage (+ 40 431) "Common Patterns in Monads and Monad Transformers")
;; (find-rwhaskellpage (+ 40 433) "Stacking Multiple Monad Transformers")
;; (find-rwhaskellpage (+ 40 435) "Hiding Our Work")
;; (find-rwhaskellpage (+ 40 436) "Moving Down the Stack")
;; (find-rwhaskellpage (+ 40 437) "When Explicit Lifting Is Necessary")
;; (find-rwhaskellpage (+ 40 438) "Understanding Monad Transformers by Building One")
;; (find-rwhaskellpage (+ 40 439) "Creating a Monad Transformer")
;; (find-rwhaskellpage (+ 40 440) "More Typeclass Instances")
;; (find-rwhaskellpage (+ 40 440) "Replacing the Parse Type with a Monad Stack")
;; (find-rwhaskellpage (+ 40 441) "Transformer Stacking Order Is Important")
;; (find-rwhaskellpage (+ 40 443) "Putting Monads and Monad Transformers into Perspective")
;; (find-rwhaskellpage (+ 40 443) "Interference with Pure Code")
;; (find-rwhaskellpage (+ 40 444) "Overdetermined Ordering")
;; (find-rwhaskellpage (+ 40 444) "Runtime Overhead")
;; (find-rwhaskellpage (+ 40 444) "Unwieldy Interfaces")
;; (find-rwhaskellpage (+ 40 445) "Pulling It All Together")
;; (find-rwhaskellpage (+ 40 447) "19. Error Handling")
;; (find-rwhaskellpage (+ 40 447) "Error Handling with Data Types")
;; (find-rwhaskellpage (+ 40 448) "Use of Maybe")
;; (find-rwhaskellpage (+ 40 452) "Use of Either")
;; (find-rwhaskellpage (+ 40 454) "Exceptions")
;; (find-rwhaskellpage (+ 40 454) "First Steps with Exceptions")
;; (find-rwhaskellpage (+ 40 455) "Laziness and Exception Handling")
;; (find-rwhaskellpage (+ 40 456) "Using handle")
;; (find-rwhaskellpage (+ 40 456) "Selective Handling of Exceptions")
;; (find-rwhaskellpage (+ 40 457) "I/O Exceptions")
;; (find-rwhaskellpage (+ 40 459) "Throwing Exceptions")
;; (find-rwhaskellpage (+ 40 459) "Dynamic Exceptions")
;; (find-rwhaskellpage (+ 40 462) "Error Handling in Monads")
;; (find-rwhaskellpage (+ 40 463) "A Tiny Parsing Framework")
;; (find-rwhaskellpage (+ 40 467) "20. Systems Programming in Haskell")
;; (find-rwhaskellpage (+ 40 467) "Running External Programs")
;; (find-rwhaskellpage (+ 40 468) "Directory and File Information")
;; (find-rwhaskellpage (+ 40 469) "Program Termination")
;; (find-rwhaskellpage (+ 40 470) "Dates and Times")
;; (find-rwhaskellpage (+ 40 470) "ClockTime and CalendarTime")
;; (find-rwhaskellpage (+ 40 475) "File Modification Times")
;; (find-rwhaskellpage (+ 40 476) "Extended Example: Piping")
;; (find-rwhaskellpage (+ 40 477) "Using Pipes for Redirection")
;; (find-rwhaskellpage (+ 40 483) "Better Piping")
;; (find-rwhaskellpage (+ 40 491) "Final Words on Pipes")
;; (find-rwhaskellpage (+ 40 493) "21. Using Databases")
;; (find-rwhaskellpage (+ 40 493) "Overview of HDBC")
;; (find-rwhaskellpage (+ 40 494) "Installing HDBC and Drivers")
;; (find-rwhaskellpage (+ 40 495) "Connecting to Databases")
;; (find-rwhaskellpage (+ 40 495) "Transactions")
;; (find-rwhaskellpage (+ 40 496) "Simple Queries")
;; (find-rwhaskellpage (+ 40 497) "SqlValue")
;; (find-rwhaskellpage (+ 40 497) "Query Parameters")
;; (find-rwhaskellpage (+ 40 498) "Prepared Statements")
;; (find-rwhaskellpage (+ 40 499) "Reading Results")
;; (find-rwhaskellpage (+ 40 501) "Reading with Statements")
;; (find-rwhaskellpage (+ 40 501) "Lazy Reading")
;; (find-rwhaskellpage (+ 40 502) "Database Metadata")
;; (find-rwhaskellpage (+ 40 503) "Error Handling")
;; (find-rwhaskellpage (+ 40 505) "22. Extended Example: Web Client Programming")
;; (find-rwhaskellpage (+ 40 506) "Basic Types")
;; (find-rwhaskellpage (+ 40 506) "The Database")
;; (find-rwhaskellpage (+ 40 510) "The Parser")
;; (find-rwhaskellpage (+ 40 513) "Downloading")
;; (find-rwhaskellpage (+ 40 515) "Main Program")
;; (find-rwhaskellpage (+ 40 517) "23. GUI Programming with gtk2hs")
;; (find-rwhaskellpage (+ 40 517) "Installing gtk2hs")
;; (find-rwhaskellpage (+ 40 517) "Overview of the GTK+ Stack")
;; (find-rwhaskellpage (+ 40 518) "User Interface Design with Glade")
;; (find-rwhaskellpage (+ 40 518) "Glade Concepts")
;; (find-rwhaskellpage (+ 40 519) "Event-Driven Programming")
;; (find-rwhaskellpage (+ 40 520) "Initializing the GUI")
;; (find-rwhaskellpage (+ 40 524) "The Add Podcast Window")
;; (find-rwhaskellpage (+ 40 525) "Long-Running Tasks")
;; (find-rwhaskellpage (+ 40 528) "Using Cabal")
;; (find-rwhaskellpage (+ 40 531) "24. Concurrent and Multicore Programming")
;; (find-rwhaskellpage (+ 40 531) "Defining Concurrency and Parallelism")
;; (find-rwhaskellpage (+ 40 532) "Concurrent Programming with Threads")
;; (find-rwhaskellpage (+ 40 532) "Threads Are Nondeterministic")
;; (find-rwhaskellpage (+ 40 532) "Hiding Latency")
;; (find-rwhaskellpage (+ 40 533) "Simple Communication Between Threads")
;; (find-rwhaskellpage (+ 40 534) "The Main Thread and Waiting for Other Threads")
;; (find-rwhaskellpage (+ 40 536) "Safely Modifying an MVar")
;; (find-rwhaskellpage (+ 40 536) "Safe Resource Management: A Good Idea, and Easy Besides")
;; (find-rwhaskellpage (+ 40 537) "Finding the Status of a Thread")
;; (find-rwhaskellpage (+ 40 538) "Writing Tighter Code")
;; (find-rwhaskellpage (+ 40 539) "Communicating over Channels")
;; (find-rwhaskellpage (+ 40 539) "Useful Things to Know About")
;; (find-rwhaskellpage (+ 40 539) "MVar and Chan Are Nonstrict")
;; (find-rwhaskellpage (+ 40 540) "Chan Is Unbounded")
;; (find-rwhaskellpage (+ 40 540) "Shared-State Concurrency Is Still Hard")
;; (find-rwhaskellpage (+ 40 541) "Deadlock")
;; (find-rwhaskellpage (+ 40 541) "Starvation")
;; (find-rwhaskellpage (+ 40 542) "Is There Any Hope?")
;; (find-rwhaskellpage (+ 40 542) "Using Multiple Cores with GHC")
;; (find-rwhaskellpage (+ 40 543) "Runtime Options")
;; (find-rwhaskellpage (+ 40 543) "Finding the Number of Available Cores from Haskell")
;; (find-rwhaskellpage (+ 40 544) "Choosing the Right Runtime")
;; (find-rwhaskellpage (+ 40 544) "Parallel Programming in Haskell")
;; (find-rwhaskellpage (+ 40 545) "Normal Form and Head Normal Form")
;; (find-rwhaskellpage (+ 40 545) "Sequential Sorting")
;; (find-rwhaskellpage (+ 40 545) "Transforming Our Code into Parallel Code")
;; (find-rwhaskellpage (+ 40 546) "Knowing What to Evaluate in Parallel")
;; (find-rwhaskellpage (+ 40 547) "What Promises Does par Make?")
;; (find-rwhaskellpage (+ 40 547) "Running Our Code and Measuring Performance")
;; (find-rwhaskellpage (+ 40 550) "Tuning for Performance")
;; (find-rwhaskellpage (+ 40 551) "Parallel Strategies and MapReduce")
;; (find-rwhaskellpage (+ 40 552) "Separating Algorithm from Evaluation")
;; (find-rwhaskellpage (+ 40 554) "Separating Algorithm from Strategy")
;; (find-rwhaskellpage (+ 40 554) "Writing a Simple MapReduce Definition")
;; (find-rwhaskellpage (+ 40 555) "MapReduce and Strategies")
;; (find-rwhaskellpage (+ 40 555) "Sizing Work Appropriately")
;; (find-rwhaskellpage (+ 40 557) "Efficiently Finding Line-Aligned Chunks")
;; (find-rwhaskellpage (+ 40 558) "Counting Lines")
;; (find-rwhaskellpage (+ 40 559) "Finding the Most Popular URLs")
;; (find-rwhaskellpage (+ 40 560) "Conclusions")
;; (find-rwhaskellpage (+ 40 561) "25. Profiling and Optimization")
;; (find-rwhaskellpage (+ 40 561) "Profiling Haskell Programs")
;; (find-rwhaskellpage (+ 40 562) "Collecting Runtime Statistics")
;; (find-rwhaskellpage (+ 40 563) "Time Profiling")
;; (find-rwhaskellpage (+ 40 566) "Space Profiling")
;; (find-rwhaskellpage (+ 40 570) "Controlling Evaluation")
;; (find-rwhaskellpage (+ 40 571) "Strictness and Tail Recursion")
;; (find-rwhaskellpage (+ 40 572) "Adding Strictness")
;; (find-rwhaskellpage (+ 40 575) "Understanding Core")
;; (find-rwhaskellpage (+ 40 578) "Advanced Techniques: Fusion")
;; (find-rwhaskellpage (+ 40 579) "Tuning the Generated Assembly")
;; (find-rwhaskellpage (+ 40 580) "Conclusions")
;; (find-rwhaskellpage (+ 40 581) "26. Advanced Library Design: Building a Bloom Filter")
;; (find-rwhaskellpage (+ 40 581) "Introducing the Bloom Filter")
;; (find-rwhaskellpage (+ 40 582) "Use Cases and Package Layout")
;; (find-rwhaskellpage (+ 40 583) "Basic Design")
;; (find-rwhaskellpage (+ 40 583) "Unboxing, Lifting, and Bottom")
;; (find-rwhaskellpage (+ 40 584) "The ST Monad")
;; (find-rwhaskellpage (+ 40 585) "Designing an API for Qualified Import")
;; (find-rwhaskellpage (+ 40 586) "Creating a Mutable Bloom Filter")
;; (find-rwhaskellpage (+ 40 587) "The Immutable API")
;; (find-rwhaskellpage (+ 40 588) "Creating a Friendly Interface")
;; (find-rwhaskellpage (+ 40 589) "Re-Exporting Names for Convenience")
;; (find-rwhaskellpage (+ 40 589) "Hashing Values")
;; (find-rwhaskellpage (+ 40 593) "Turning Two Hashes into Many")
;; (find-rwhaskellpage (+ 40 593) "Implementing the Easy Creation Function")
;; (find-rwhaskellpage (+ 40 595) "Creating a Cabal Package")
;; (find-rwhaskellpage (+ 40 596) "Dealing with Different Build Setups")
;; (find-rwhaskellpage (+ 40 598) "Compilation Options and Interfacing to C")
;; (find-rwhaskellpage (+ 40 599) "Testing with QuickCheck")
;; (find-rwhaskellpage (+ 40 600) "Polymorphic Testing")
;; (find-rwhaskellpage (+ 40 601) "Writing Arbitrary Instances for ByteStrings")
;; (find-rwhaskellpage (+ 40 602) "Are Suggested Sizes Correct?")
;; (find-rwhaskellpage (+ 40 604) "Performance Analysis and Tuning")
;; (find-rwhaskellpage (+ 40 605) "Profile-Driven Performance Tuning")
;; (find-rwhaskellpage (+ 40 611) "27. Sockets and Syslog")
;; (find-rwhaskellpage (+ 40 611) "Basic Networking")
;; (find-rwhaskellpage (+ 40 611) "Communicating with UDP")
;; (find-rwhaskellpage (+ 40 612) "UDP Client Example: syslog")
;; (find-rwhaskellpage (+ 40 615) "UDP Syslog Server")
;; (find-rwhaskellpage (+ 40 616) "Communicating with TCP")
;; (find-rwhaskellpage (+ 40 616) "Handling Multiple TCP Streams")
;; (find-rwhaskellpage (+ 40 617) "TCP Syslog Server")
;; (find-rwhaskellpage (+ 40 619) "TCP Syslog Client")
;; (find-rwhaskellpage (+ 40 623) "28. Software Transactional Memory")
;; (find-rwhaskellpage (+ 40 623) "The Basics")
;; (find-rwhaskellpage (+ 40 624) "Some Simple Examples")
;; (find-rwhaskellpage (+ 40 626) "STM and Safety")
;; (find-rwhaskellpage (+ 40 626) "Retrying a Transaction")
;; (find-rwhaskellpage (+ 40 628) "What Happens When We Retry?")
;; (find-rwhaskellpage (+ 40 628) "Choosing Between Alternatives")
;; (find-rwhaskellpage (+ 40 628) "Using Higher Order Code with Transactions")
;; (find-rwhaskellpage (+ 40 629) "I/O and STM")
;; (find-rwhaskellpage (+ 40 630) "Communication Between Threads")
;; (find-rwhaskellpage (+ 40 631) "A Concurrent Web Link Checker")
;; (find-rwhaskellpage (+ 40 633) "Checking a Link")
;; (find-rwhaskellpage (+ 40 634) "Worker Threads")
;; (find-rwhaskellpage (+ 40 635) "Finding Links")
;; (find-rwhaskellpage (+ 40 636) "Command-Line Parsing")
;; (find-rwhaskellpage (+ 40 637) "Pattern Guards")
;; (find-rwhaskellpage (+ 40 638) "Practical Aspects of STM")
;; (find-rwhaskellpage (+ 40 638) "Getting Comfortable with Giving Up Control")
;; (find-rwhaskellpage (+ 40 639) "Using Invariants")
;; (find-rwhaskellpage (+ 40 641) "A. Installing GHC and Haskell Libraries")
;; (find-rwhaskellpage (+ 40 649) "B. Characters, Strings, and Escaping Rules")
;; (find-rwhaskellpage (+ 40 655) "Index")
;; «haskell-2010» (to ".haskell-2010")
;; (find-books "__comp/__comp.el" "haskell-2010")
;; https://www.haskell.org/definition/haskell2010.pdf
(code-pdf-page "haskell2010" "$S/https/www.haskell.org/definition/haskell2010.pdf")
(code-pdf-text "haskell2010" "$S/https/www.haskell.org/definition/haskell2010.pdf" 20)
;; (find-haskell2010page)
;; (find-haskell2010text)
;; (find-haskell2010page (+ 20 25) "3.15 Datatypes with Field Labels")
;; (find-haskell2010text (+ 20 25) "3.15 Datatypes with Field Labels")
;; (find-haskell2010page (+ 20 26) "3.15.2 Construction Using Field Labels")
;; (find-haskell2010text (+ 20 26) "3.15.2 Construction Using Field Labels")
;; (find-haskell2010text (+ 20 26) "3.15.2 Construction Using Field Labels" "record")
;; (find-haskell2010page (+ 20 45) "4.3.2 Instance Declarations")
;; (find-haskell2010text (+ 20 45) "4.3.2 Instance Declarations")
;; http://gigapedia.com/items/28927/haskell--the-craft-of-functional-programming--2nd-edition-
(code-djvu "haskellcraft" "~/books/__comp/thompson__haskell_the_craft_of_functional_programming.djvu")
;; (find-haskellcraftpage 4 "Contents")
;; (find-haskellcraftpage (+ 17 472) "Index")
;; http://gigapedia.com/items/216374/real-world-haskell
;; (find-unpack-chm-links "~/books/__comp/o_sullivan_stewart_goerzen__real_world_haskell.chm" "~/usrc/rwhaskell/" "rwhaskell")
(code-c-d "rwhaskell" "~/usrc/rwhaskell/")
;; (find-rwhaskellfile "")
;; (find-rwhaskellw3m "Toc.html")
;; «html-1998» (to ".html-1998")
;; (find-books "__comp/__comp.el" "html-1998")
(code-pdf-page "musciano98" "~/books/__comp/musciano_kennedy__html_the_definitive_guide_1998.pdf")
(code-pdf-text "musciano98" "~/books/__comp/musciano_kennedy__html_the_definitive_guide_1998.pdf" 1)
;; (find-musciano98page)
;; (find-musciano98text "")
;; (find-musciano98page 1 "Table of Contents")
;; (find-musciano98page 3 "Preface")
;; (find-musciano98page 11 "Chapter 1: HTML and the World Wide Web")
;; (find-musciano98page 27 "Chapter 2: HTML Quick Start")
;; (find-musciano98page 56 "Chapter 3: Anatomy of an HTML Document")
;; (find-musciano98page 80 "Chapter 4: Text Basics")
;; (find-musciano98page 138 "Chapter 5: Rules, Images, and Multimedia")
;; (find-musciano98page 183 "Chapter 6: Document Layout")
;; (find-musciano98page 207 "Chapter 7: Links and Webs")
;; (find-musciano98page 262 "Chapter 8: Formatted Lists")
;; (find-musciano98page 287 "Chapter 9: Cascading Style Sheets")
;; (find-musciano98page 330 "Chapter 10: Forms")
;; (find-musciano98page 379 "Chapter 11: Tables")
;; (find-musciano98page 413 "Chapter 12: Frames")
;; (find-musciano98page 436 "Chapter 13: Executable Content")
;; (find-musciano98page 470 "Chapter 14: Dynamic Documents")
;; (find-musciano98page 481 "Chapter 15: Tips, Tricks, and Hacks")
;; (find-musciano98page 499 "Appendix A: HTML Grammar")
;; (find-musciano98page 513 "Appendix B: HTML Tag Quick Reference")
;; (find-musciano98page 555 "Appendix C: Cascading Style Sheet Properties Quick Reference")
;; (find-musciano98page 562 "Appendix D: The HTML 4.0 DTD")
;; (find-musciano98page 578 "Appendix E: Character Entities")
;; (find-musciano98page 584 "Appendix F: Color Names and Values")
;; «javascript» (to ".javascript")
;; (to "crockford")
;; (find-es "javascript" "crockford")
;; (find-fline "~/books/__comp/")
(code-xpdf "crockford" "~/books/__comp/crockford__javascript_the_good_parts.pdf")
(code-pdf-text "crockford" "~/books/__comp/crockford__javascript_the_good_parts.pdf" 16)
;; (find-crockfordpage)
;; (find-crockfordpage 9 "Contents")
;; (find-crockfordtext 9 "Contents")
;; (find-crockfordtext)
;; (find-crockfordpage (+ 16 65) "Regular Expressions")
;; (find-crockfordtext (+ 16 65) "Regular Expressions")
;; http://gigapedia.com/items/115692/javascript--the-good-parts
;; http://www.youtube.com/watch?v=hQVTIJBZook
;; http://video.yahoo.com/watch/630959/2974197
;; (find-unpack-chm-links "~/books/__comp/crockford__javascript_the_good_parts.chm" "~/usrc/crockford/" "crockford")
(code-c-d "crockford" "~/usrc/crockford/final/")
;; (find-crockfordw3m "toc.html")
;; (find-crockfordw3m "a_simple_testing_ground.html" "1.3. A Simple Testing Ground")
;; (find-crockfordw3m "exceptions.html" "4.6. Exceptions")
;; http://javascript.crockford.com/javascript.html
;; (find-unpack-chm-links "~/books/__comp/flanagan__javascript_the_definitive_guide_5th_ed.chm" "~/usrc/flanagan-jsdg5/" "flanaganjsdg5")
(code-c-d "flanaganjsdg5" "~/usrc/flanagan-jsdg5/0596101996/")
;; (find-flanaganjsdg5file "")
;; (find-flanaganjsdg5w3m "toc.html")
;; (find-flanaganjsdg5w3m "jscript5-CHP-6-SECT-16.html" "6.16. throw")
;; (find-flanaganjsdg5w3m "jscript5-CHP-6-SECT-17.html" "6.17. try/catch/finally")
;; (find-unpack-chm-links "/home/edrx/books/__comp/flanagan__javascript_pocket_reference_2nd_ed.chm" "~/usrc/flanagan-jspr2/" "flanaganjspr2")
(code-c-d "flanaganjspr2" "~/usrc/flanagan-jspr2/")
;; (find-flanaganjspr2file "")
;; (find-flanaganjspr2w3m "toc.html")
;; (find-flanaganjspr2w3m "jscriptpr2-CHP-1-SECT-2.2.html" "2.2 The Window Object")
;; (find-flanaganjspr2w3m "jscriptpr2-CHP-1-SECT-2.4.html" "2.4 The Legacy DOM")
;; (find-flanaganjspr2w3m "jscriptpr2-CHP-1-SECT-2.5.html" "2.5 The W3C DOM")
;; «latex» (to ".latex")
;; (find-angg ".emacs.papers" "kopkadaly")
;; http://gigapedia.com/items/125839/guide-to-latex--4th-edition---tools-and-techniques-for-computer-typesetting-
(code-xpdf "kopkadaly" "~/books/__comp/kopka_daly__a_guide_to_latex_4th_ed.pdf")
;; (find-kopkadalypage 7 "Contents")
;; (find-kopkadalypage (+ 12 607) "Index")
;; https://link.springer.com/book/10.1007/978-3-319-47831-9
;; https://link.springer.com/content/pdf/10.1007%2F978-3-319-47831-9.pdf
(code-pdf-page "dattalatex" "~/books/__comp/datta__latex_in_24_hours.pdf")
(code-pdf-text "dattalatex" "~/books/__comp/datta__latex_in_24_hours.pdf")
;; (find-dattalatexpage)
;; (find-dattalatextext)
;; http://gigapedia.com/items/28942/latex--a-document-preparation-system--second-edition
(code-djvu "lamportlatex" "~/books/__comp/lamport__latex_document_preparation_system.djvu")
;; (find-lamportlatexpage 5 "Contents")
;; (find-lamportlatexpage (+ 17 237) "Index")
;; http://gigapedia.com/items/130856/lamstex--the-synthesis
(code-djvu "lamstex" "~/books/__comp/spivak__lamstex_the_synthesis.djvu")
;; (find-lamstexpage 3 "Contents")
;; (find-lamstexpage (+ 5 263) "Index")
;; http://gigapedia.com/items/104326/the-joy-of-tex--a-gourmet-guide-to-typesetting-with-the-ams-tex-macro-package
(code-djvu "joyoftex" "~/books/__comp/spivak__the_joy_of_tex.djvu")
;; (find-joyoftexpage 4 "Contents")
;; (find-joyoftexpage (+ 9 283) "Index")
;; «lpeg-fromre» (to ".lpeg-fromre")
;; Sergio Medeiros, Fabio Mascarenhas, Roberto Ierusalimschy:
;; "From Regular Expressions to Parsing Expression Grammars"
;; http://www.lua.inf.puc-rio.br/publications/medeiros11regular.pdf
(code-pdf-page "lpegfromre" "$S/http/www.lua.inf.puc-rio.br/publications/medeiros11regular.pdf")
(code-pdf-text "lpegfromre" "$S/http/www.lua.inf.puc-rio.br/publications/medeiros11regular.pdf")
;; (find-lpegfromrepage)
;; (find-lpegfromretext)
;; «lpeg-pmp» (to ".lpeg-pmp")
;; http://www.inf.puc-rio.br/~roberto/docs/ry08-4.pdf
;; Sérgio Medeiros, Roberto Ierusalimschy: "A Parsing Machine for PEGs"
;; (find-fline "$S/http/www.inf.puc-rio.br/~roberto/docs/")
(code-pdf-page "lpegpmp" "$S/http/www.inf.puc-rio.br/~roberto/docs/ry08-4.pdf")
(code-pdf-text "lpegpmp" "$S/http/www.inf.puc-rio.br/~roberto/docs/ry08-4.pdf")
;; (find-lpegpmppage)
;; (find-lpegpmptext)
;; «lpeg-redz» (to ".lpeg-redz")
;; http://www.romanredz.se/papers/FI2017.pdf
(code-pdf-page "redzipeg" "$S/http/www.romanredz.se/papers/FI2017.pdf")
(code-pdf-text "redzipeg" "$S/http/www.romanredz.se/papers/FI2017.pdf")
;; (find-redzipegpage)
;; (find-redzipegtext)
;; (find-redzipegpage 1 "1 Introduction")
;; (find-redzipegtext 1 "1 Introduction")
;; (find-redzipegpage 2 "2 The grammar")
;; (find-redzipegtext 2 "2 The grammar")
;; (find-redzipegpage 4 "3 Disjoint choice and efficient backtracking")
;; (find-redzipegtext 4 "3 Disjoint choice and efficient backtracking")
;; (find-redzipegpage 5 "4 PEG Explorer")
;; (find-redzipegtext 5 "4 PEG Explorer")
;; (find-redzipegpage 7 "5 Final remarks")
;; (find-redzipegtext 7 "5 Final remarks")
;; «lpeg-rel» (to ".lpeg-rel")
;; https://arxiv.org/abs/1304.3177
;; https://arxiv.org/pdf/1304.3177.pdf
;; Fabio Mascarenhas, Sergio Medeiros, Roberto Ierusalimschy:
;; "On the Relation between Context-Free Grammars and Parsing Expression Grammars"
(code-pdf-page "lpegrel" "$S/https/arxiv.org/pdf/1304.3177.pdf")
(code-pdf-text "lpegrel" "$S/https/arxiv.org/pdf/1304.3177.pdf")
;; (find-lpegrelpage)
;; (find-lpegreltext)
;; «lpeg-medeirosphd» (to ".lpeg-medeirosphd")
;; http://www.lua.inf.puc-rio.br/publications/2010-SergioMedeiros-phd-thesis.pdf
(code-pdf-page "medeirosphd" "$S/http/www.lua.inf.puc-rio.br/publications/2010-SergioMedeiros-phd-thesis.pdf")
(code-pdf-text "medeirosphd" "$S/http/www.lua.inf.puc-rio.br/publications/2010-SergioMedeiros-phd-thesis.pdf")
;; (find-medeirosphdpage)
;; (find-medeirosphdtext)
;; (find-medeirosphdpage 7 "Sumario")
;; (find-medeirosphdtext 7 "Sumario")
;; (find-medeirosphdpage 11 "1 Introducao")
;; (find-medeirosphdpage 13 "1.1 Visao Geral de PEGs")
;; (find-medeirosphdpage 19 "1.2 Organizacao da Tese")
;; (find-medeirosphdpage 20 "2 Gramaticas de Expressoes de Parsing")
;; (find-medeirosphdpage 20 "2.1 Definicao de PEGs")
;; (find-medeirosphdpage 21 "2.2 Interpretacao de PEGs Usando a Relacao G")
;; (find-medeirosphdpage 23 "2.3 Formalizacao de PEGs Usando Semantica Natural")
;; (find-medeirosphdpage 32 "3 Expressoes Regulares e PEGs")
;; (find-medeirosphdpage 32 "3.1 Expressoes Regulares")
;; (find-medeirosphdpage 33 "3.2 Definicao de Expressoes Regulares Usando Semantica Natural")
;; (find-medeirosphdpage 37 "3.3 Equivalencia Entre Expressoes Regulares e PEGs")
;; (find-medeirosphdpage 39 "3.4 Transformacao de uma Expressao Regular em uma PEG Equivalente")
;; (find-medeirosphdpage 42 "3.5 Transformacao de Repeticoes e1 onde e1 Casa a Cadeia Vazia")
;; (find-medeirosphdpage 46 "3.6 Corretude da Transformacao")
;; (find-medeirosphdpage 52 "4 Gramaticas Livres de Contexto e PEGs")
;; (find-medeirosphdpage 52 "4.1 Definicao Usual de CFGs")
;; (find-medeirosphdpage 53 "4.2 Uma Nova Formalizacao de Linguagens Livres de Contexto usando Semantica Natural")
;; (find-medeirosphdpage 59 "4.3 Correspondencia entre !CFG e !PEG")
;; (find-medeirosphdpage 61 "4.4 Correspondencia entre CFGs Lineares a Direita e PEGs")
;; (find-medeirosphdpage 63 "4.5 Correspondencia entre CFGs LL(1) e PEGs")
;; (find-medeirosphdpage 72 "4.6 Correspondencia entre CFGs LL(k)-Forte e PEGs")
;; (find-medeirosphdpage 80 "5 Conclusao")
;; (find-medeirosphdpage 80 "5.1 Trabalhos Relacionados")
;; (find-medeirosphdpage 82 "5.2 Contribuicoes")
;; «lilypond» (to ".lilypond")
;; (find-books "__comp/__comp.el" "lilypond")
;; (find-es "lilypond" "lilypond-2020")
;; (find-angg ".emacs" "lilypond")
(progn
(code-c-d "lilydoc" "/usr/share/doc/lilypond/html/Documentation/")
(code-pdf-page "lilyessay" "/usr/share/doc/lilypond/html/Documentation/essay.pdf")
(code-pdf-text "lilyessay" "/usr/share/doc/lilypond/html/Documentation/essay.pdf")
(code-pdf-page "lilylearn" "/usr/share/doc/lilypond/html/Documentation/learning.pdf")
(code-pdf-text "lilylearn" "/usr/share/doc/lilypond/html/Documentation/learning.pdf" 5)
(code-pdf-page "lilysnipp" "/usr/share/doc/lilypond/html/Documentation/snippets.pdf")
(code-pdf-text "lilysnipp" "/usr/share/doc/lilypond/html/Documentation/snippets.pdf")
(code-pdf-page "lilynotat" "/usr/share/doc/lilypond/html/Documentation/notation.pdf")
(code-pdf-text "lilynotat" "/usr/share/doc/lilypond/html/Documentation/notation.pdf")
)
;; (find-lilydocfile "")
;; (find-lilynotatpage)
;; (find-lilynotattext)
;; (find-lilysnipppage)
;; (find-lilysnipptext)
;; (find-lilyessaypage)
;; (find-lilyessaytext)
;; (find-lilylearnpage)
;; (find-lilylearntext)
;; (find-lilylearnpage 2 "Table of Contents")
;; (find-lilylearntext 2 "Table of Contents")
;; (find-lilylearnpage (+ 5 1) "1 Tutorial")
;; (find-lilylearnpage (+ 5 1) "1.1 Compiling a file")
;; (find-lilylearnpage (+ 5 1) "1.1.1 Entering input")
;; (find-lilylearnpage (+ 5 1) "Producing output")
;; (find-lilylearnpage (+ 5 2) "1.1.2 MacOS X.")
;; (find-lilylearnpage (+ 5 6) "1.1.3 Windows")
;; (find-lilylearnpage (+ 5 11) "1.1.4 Command-line")
;; (find-lilylearnpage (+ 5 12) "1.2 How to write input files")
;; (find-lilylearnpage (+ 5 12) "1.2.1 Simple notation")
;; (find-lilylearnpage (+ 5 12) "Pitches")
;; (find-lilylearnpage (+ 5 14) "Durations (rhythms)")
;; (find-lilylearnpage (+ 5 15) "Rests")
;; (find-lilylearnpage (+ 5 15) "Time signature")
;; (find-lilylearnpage (+ 5 15) "Tempo marks")
;; (find-lilylearnpage (+ 5 16) "Clef")
;; (find-lilylearnpage (+ 5 16) "All together")
;; (find-lilylearnpage (+ 5 16) "1.2.2 Working on input files")
;; (find-lilylearnpage (+ 5 18) "1.3 Dealing with errors")
;; (find-lilylearnpage (+ 5 18) "1.3.1 General troubleshooting tips")
;; (find-lilylearnpage (+ 5 18) "1.3.2 Some common errors")
;; (find-lilylearnpage (+ 5 18) "1.4 How to read the manuals")
;; (find-lilylearnpage (+ 5 18) "1.4.1 Omitted material")
;; (find-lilylearnpage (+ 5 18) "1.4.2 Clickable examples")
;; (find-lilylearnpage (+ 5 19) "1.4.3 Overview of manuals")
;; (find-lilylearnpage (+ 5 20) "2 Common notation")
;; (find-lilylearnpage (+ 5 20) "2.1 Single staff notation")
;; (find-lilylearnpage (+ 5 20) "2.1.1 Bar lines and bar checks")
;; (find-lilylearnpage (+ 5 20) "Bar lines")
;; (find-lilylearnpage (+ 5 20) "Bar checks")
;; (find-lilylearnpage (+ 5 20) "2.1.2 Accidentals and key signatures")
;; (find-lilylearnpage (+ 5 20) "Accidentals.")
;; (find-lilylearnpage (+ 5 21) "Key signatures")
;; (find-lilylearnpage (+ 5 21) "Warning: key signatures and pitches")
;; (find-lilylearnpage (+ 5 22) "2.1.3 Ties and slurs")
;; (find-lilylearnpage (+ 5 22) "Ties")
;; (find-lilylearnpage (+ 5 22) "Slurs")
;; (find-lilylearnpage (+ 5 22) "Phrasing slurs")
;; (find-lilylearnpage (+ 5 23) "Warnings: slurs vs. ties.")
;; (find-lilylearnpage (+ 5 23) "2.1.4 Articulation and dynamics")
;; (find-lilylearnpage (+ 5 23) "Articulations")
;; (find-lilylearnpage (+ 5 23) "Fingerings.")
;; (find-lilylearnpage (+ 5 24) "Dynamics")
;; (find-lilylearnpage (+ 5 24) "2.1.5 Adding text")
;; (find-lilylearnpage (+ 5 25) "2.1.6 Automatic and manual beams")
;; (find-lilylearnpage (+ 5 25) "2.1.7 Advanced rhythmic commands")
;; (find-lilylearnpage (+ 5 25) "Partial measure")
;; (find-lilylearnpage (+ 5 26) "Tuplets")
;; (find-lilylearnpage (+ 5 26) "Grace notes")
;; (find-lilylearnpage (+ 5 26) "2.2 Multiple notes at once")
;; (find-lilylearnpage (+ 5 26) "2.2.1 Music expressions explained")
;; (find-lilylearnpage (+ 5 27) "Analogy: mathematical expressions")
;; (find-lilylearnpage (+ 5 27) "Simultaneous music expressions: multiple staves")
;; (find-lilylearnpage (+ 5 28) "Simultaneous music expressions: single staff")
;; (find-lilylearnpage (+ 5 28) "2.2.2 Multiple staves")
;; (find-lilylearnpage (+ 5 29) "2.2.3 Staff groups")
;; (find-lilylearnpage (+ 5 30) "2.2.4 Combining notes into chords")
;; (find-lilylearnpage (+ 5 30) "2.2.5 Single staff polyphony")
;; (find-lilylearnpage (+ 5 31) "2.3 Songs")
;; (find-lilylearnpage (+ 5 31) "2.3.1 Setting simple songs")
;; (find-lilylearnpage (+ 5 31) "2.3.2 Aligning lyrics to a melody")
;; (find-lilylearnpage (+ 5 35) "2.3.3 Lyrics to multiple staves")
;; (find-lilylearnpage (+ 5 36) "2.4 Final touches")
;; (find-lilylearnpage (+ 5 36) "2.4.1 Organizing pieces with variables")
;; (find-lilylearnpage (+ 5 37) "2.4.2 Adding titles")
;; (find-lilylearnpage (+ 5 37) "2.4.3 Absolute note names")
;; (find-lilylearnpage (+ 5 39) "2.4.4 After the tutorial")
;; (find-lilylearnpage (+ 5 40) "3 Fundamental concepts")
;; (find-lilylearnpage (+ 5 40) "3.1 How LilyPond input files work")
;; (find-lilylearnpage (+ 5 40) "3.1.1 Introduction to the LilyPond file structure")
;; (find-lilylearnpage (+ 5 42) "3.1.2 Score is a (single) compound musical expression")
;; (find-lilylearnpage (+ 5 44) "3.1.3 Nesting music expressions")
;; (find-lilylearnpage (+ 5 45) "3.1.4 On the un-nestedness of brackets and ties")
;; (find-lilylearnpage (+ 5 46) "3.2 Voices contain music")
;; (find-lilylearnpage (+ 5 47) "3.2.1 I'm hearing Voices")
;; (find-lilylearnpage (+ 5 51) "3.2.2 Explicitly instantiating voices")
;; (find-lilylearnpage (+ 5 55) "3.2.3 Voices and vocals")
;; (find-lilylearnpage (+ 5 57) "3.3 Contexts and engravers")
;; (find-lilylearnpage (+ 5 58) "3.3.1 Contexts explained")
;; (find-lilylearnpage (+ 5 59) "3.3.2 Creating contexts")
;; (find-lilylearnpage (+ 5 60) "3.3.3 Engravers explained")
;; (find-lilylearnpage (+ 5 61) "3.3.4 Modifying context properties")
;; (find-lilylearnpage (+ 5 66) "3.3.5 Adding and removing engravers")
;; (find-lilylearnpage (+ 5 69) "3.4 Extending the templates")
;; (find-lilylearnpage (+ 5 69) "3.4.1 Soprano and cello")
;; (find-lilylearnpage (+ 5 72) "3.4.2 Four-part SATB vocal score")
;; (find-lilylearnpage (+ 5 77) "3.4.3 Building a score from scratch")
;; (find-lilylearnpage (+ 5 82) "3.4.4 Saving typing with variables and functions")
;; (find-lilylearnpage (+ 5 84) "3.4.5 Scores and parts")
;; «lua-gems» (to ".lua-gems")
;; (find-books "__comp/__comp.el" "lua-gems")
;; http://www.lua.org/gems/
;; (find-TH "miniforth-article")
(code-pdf-page "luagems" "~/books/__comp/lhf_celes_ierusalimschy__lua_programming_gems.pdf")
(code-pdf-text "luagems" "~/books/__comp/lhf_celes_ierusalimschy__lua_programming_gems.pdf" 1)
;; (find-luagemspage)
;; (find-luagemstext "")
;; (find-luagemspage 3 "Contents")
;; (find-luagemstext 3 "Contents")
;; (find-luagemspage (+ 12 3) "1 Lua Per-Thread Library Context")
;; (find-luagemspage (+ 12 15) "2 Lua Performance Tips")
;; (find-luagemspage (+ 12 29) "3 Vardump: The Power of Seeing What's Behind")
;; (find-luagemspage (+ 12 33) "4 Serialization with Pluto")
;; (find-luagemspage (+ 11 43) "5 Abstractions for LuaSQL")
;; (find-luagemspage (+ 10 57) "6 Boostrapping a Forth in 40 Lines of Lua Code")
;; (find-luagemspage (+ 10 71) "7 Effecting Large-Scale Change (with little trauma) using Metatables")
;; (find-luagemspage (+ 8 85) "8 MVC Web Development with Kepler")
;; (find-luagemspage (+ 8 97) "9 Filters, Sources, Sinks, and Pumps")
;; (find-luagemspage (+ 7 109) "10 Lua as a Protocol Language")
;; (find-luagemspage (+ 6 119) "11 Lua Script Packaging")
;; (find-luagemspage (+ 5 129) "12 Objects, Lua-style")
;; (find-luagemspage (+ 4 135) "13 Exceptions in Lua")
;; (find-luagemspage (+ 2 149) "14 Word Ladders")
;; (find-luagemspage (+ 2 155) "15 Building Data Structures and Iterators in Lua")
;; (find-luagemspage (+ 1 173) "16 A Primer of Scientific Computing in Lua")
;; (find-luagemspage (+ 1 201) "17 Complex Structured Data Input")
;; (find-luagemspage (+ 1 211) "18 Lua Implementations of Common Data Structures")
;; (find-luagemspage (+ 1 239) "19 Tic-Tac-Toe and the Minimax Decision Algorithm")
;; (find-luagemspage (+ -1 249) "20 Using Lua in Game and Tool Creation")
;; (find-luagemspage (+ -1 259) "21 A Dynamic and Flexible Event System for Script-Driven Games")
;; (find-luagemspage (+ -2 269) "22 Lua for Game Programming")
;; (find-luagemspage (+ -3 281) "23 Designing an Efficient Lua Driven Game Scripting Engine")
;; (find-luagemspage (+ -5 291) "24 Enhanced Coroutines in Lua")
;; (find-luagemspage (+ -6 301) "25 Using Lua in Pascal")
;; (find-luagemspage (+ -7 313) "26 Porting Lua to a Microcontroller")
;; (find-luagemspage (+ -7 325) "27 Writing C/C++ Modules for Lua")
;; (find-luagemspage (+ -7 337) "28 Interpreted C Modules")
;; «make» (to ".make")
;; (find-books "__comp/__comp.el" "make")
(code-pdf-page "mpwmake" "~/books/__comp/mecklenburg__managing_projects_with_gnu_make_3rd_ed.pdf")
(code-pdf-text "mpwmake" "~/books/__comp/mecklenburg__managing_projects_with_gnu_make_3rd_ed.pdf" 7)
;; (find-mpwmakepage)
;; (find-mpwmakepage 3 "Contents")
;; (find-mpwmakepage (+ 7 1) "1. Basic Concepts")
;; (find-mpwmakepage (+ 3 271) "Index")
;; (find-mpwmaketext "")
;; «maxima» (to ".maxima")
;; (find-es "maxima" "books")
;; «maximabook» (to ".maximabook")
;; (find-books "__comp/__comp.el" "maximabook")
;; https://maxima.sourceforge.io/docs/maximabook/maximabook-19-Sept-2004.pdf
;; Paulo Ney de Souza, Richard J. Fateman, Joel Moses, Cliff Yapp: "The Maxima Book"
;; pdftotext doesn't work here: (find-fline "/usr/share/doc/maxima-doc/" "maximabook-19-Sept-2004.pdf.gz")
(code-pdf-page "maximabook" "$S/https/maxima.sourceforge.io/docs/maximabook/maximabook-19-Sept-2004.pdf")
(code-pdf-text "maximabook" "$S/https/maxima.sourceforge.io/docs/maximabook/maximabook-19-Sept-2004.pdf" 1)
;; (find-maximabookpage)
;; (find-maximabooktext)
;; (find-maximabookpage (+ 1 5) "Preface")
;; (find-maximabookpage (+ 1 6) "I The Maxima Program and Standard Packages")
;; (find-maximabookpage (+ 1 7) "1 Introduction")
;; (find-maximabookpage (+ 1 7) "1.1 What is Maxima?")
;; (find-maximabookpage (+ 1 8) "1.2 A Brief History of Macsyma")
;; (find-maximabookpage (+ 1 10) "2 Available Interfaces to Maxima")
;; (find-maximabookpage (+ 1 10) "2.1 The Terminal Interface")
;; (find-maximabookpage (+ 1 11) "2.2 The Emacs Interface")
;; (find-maximabookpage (+ 1 11) "2.2.1 Installing the Maxima Emacs Mode")
;; (find-maximabookpage (+ 1 12) "2.2.2 Maxima-mode")
;; (find-maximabookpage (+ 1 14) "2.2.3 Enhanced Terminal Mode")
;; (find-maximabookpage (+ 1 14) "2.2.4 Emaxima Mode")
;; (find-maximabookpage (+ 1 26) "2.3 Xmaxima")
;; (find-maximabookpage (+ 1 27) "2.4 TEXmacs")
;; (find-maximabookpage (+ 1 27) "2.5 Other Interfaces")
;; (find-maximabookpage (+ 1 29) "3 The Basics - What you need to know to operate in Maxima")
;; (find-maximabookpage (+ 1 29) "3.1 The Very Beginning")
;; (find-maximabookpage (+ 1 29) "3.1.1 Our first Maxima Session")
;; (find-maximabookpage (+ 1 33) "3.1.2 To Evaluate or Not to Evaluate")
;; (find-maximabookpage (+ 1 33) "3.1.3 The Concept of Environment - The ev Command")
;; (find-maximabookpage (+ 1 38) "3.1.4 Clearing values from the system - the kill command")
;; (find-maximabookpage (+ 1 38) "3.2 Common Operators in Maxima")
;; (find-maximabookpage (+ 1 38) "3.2.1 Assignment Operators")
;; (find-maximabookpage (+ 1 42) "4 Trig through Calculus")
;; (find-maximabookpage (+ 1 42) "4.1 Trigonometric Functions")
;; (find-maximabookpage (+ 1 43) "4.2 Differentiation")
;; (find-maximabookpage (+ 1 45) "4.3 Integration")
;; (find-maximabookpage (+ 1 46) "4.3.1 The assume Command")
;; (find-maximabookpage (+ 1 47) "4.3.2 Definite Integrals")
;; (find-maximabookpage (+ 1 48) "4.3.3 changevar")
;; (find-maximabookpage (+ 1 48) "4.3.4 Behind the Black Box - Using Specific Approaches")
;; (find-maximabookpage (+ 1 48) "4.3.5 Other Examples")
;; (find-maximabookpage (+ 1 50) "5 Advanced Mathematics - ODEs and Beyond")
;; (find-maximabookpage (+ 1 50) "5.1 Ordinary Differential Equations")
;; (find-maximabookpage (+ 1 50) "5.1.1 Defining Ordinary Differential Equations")
;; (find-maximabookpage (+ 1 51) "5.1.2 Solving Ordinary Differential Equations: ode2")
;; (find-maximabookpage (+ 1 57) "5.1.3 Solving Ordinary Differential Equations: desolve")
;; (find-maximabookpage (+ 1 60) "6 Matrix Operations and Vectors")
;; (find-maximabookpage (+ 1 61) "7 Introduction to Maxima's Programming Language")
;; (find-maximabookpage (+ 1 61) "7.1 Some Examples")
;; (find-maximabookpage (+ 1 62) "7.2 Unconventional Conditionals")
;; (find-maximabookpage (+ 1 62) "7.3 Assumptions")
;; (find-maximabookpage (+ 1 63) "7.4 Arbitrary Numbers of Parameters")
;; (find-maximabookpage (+ 1 63) "7.5 Arrays")
;; (find-maximabookpage (+ 1 64) "7.6 Iteration")
;; (find-maximabookpage (+ 1 64) "7.7 Serious Business")
;; (find-maximabookpage (+ 1 65) "7.8 Hardcopy")
;; (find-maximabookpage (+ 1 65) "7.9 Return to Arrays and Functions")
;; (find-maximabookpage (+ 1 65) "7.10 More Useful Examples")
;; (find-maximabookpage (+ 1 67) "7.11 Part Hacking")
;; (find-maximabookpage (+ 1 68) "7.12 User Representation of Data")
;; (find-maximabookpage (+ 1 70) "8 Graphics and Forms of Output")
;; (find-maximabookpage (+ 1 70) "8.1 Options on the Command Line")
;; (find-maximabookpage (+ 1 70) "8.1.1 1D vs. 2D")
;; (find-maximabookpage (+ 1 70) "8.1.2 TeX Strings as Output")
;; (find-maximabookpage (+ 1 71) "8.1.3 Writing a Session to a File")
;; (find-maximabookpage (+ 1 73) "8.2 Graphics")
;; (find-maximabookpage (+ 1 73) "8.2.1 2D function plotting")
;; (find-maximabookpage (+ 1 73) "8.2.2 3D Function Plotting")
;; (find-maximabookpage (+ 1 74) "8.3 Plot Options")
;; (find-maximabookpage (+ 1 80) "9 Maxims for the Maxima User")
;; (find-maximabookpage (+ 1 82) "10 Help Systems and Debugging")
;; (find-maximabookpage (+ 1 83) "11 Troubleshooting")
;; (find-maximabookpage (+ 1 84) "12 Advanced Examples")
;; (find-maximabookpage (+ 1 87) "II External, Additional, and Contributed Packages")
;; (find-maximabookpage (+ 1 88) "13 The Concept of Packages - Expanding Maxima's Abilities")
;; (find-maximabookpage (+ 1 89) "14 Algebra")
;; (find-maximabookpage (+ 1 90) "15 Calculus")
;; (find-maximabookpage (+ 1 90) "15.1 asympa")
;; (find-maximabookpage (+ 1 91) "15.2 pdiff - Positional Derivatives")
;; (find-maximabookpage (+ 1 100) "15.3 qual")
;; (find-maximabookpage (+ 1 101) "16 Combinatorics")
;; (find-maximabookpage (+ 1 102) "17 Differential Equations")
;; (find-maximabookpage (+ 1 103) "18 Graphics")
;; (find-maximabookpage (+ 1 104) "19 Integequations")
;; (find-maximabookpage (+ 1 105) "20 Integration")
;; (find-maximabookpage (+ 1 106) "21 Macro")
;; (find-maximabookpage (+ 1 107) "22 Matrix")
;; (find-maximabookpage (+ 1 108) "23 Numeric")
;; (find-maximabookpage (+ 1 109) "24 Physics")
;; (find-maximabookpage (+ 1 109) "24.1 dimen")
;; (find-maximabookpage (+ 1 110) "24.2 dimension - Advanced Dimensional Analysis")
;; (find-maximabookpage (+ 1 118) "24.3 physconst - Definitions for Physical Constants")
;; (find-maximabookpage (+ 1 119) "25 Simplification")
;; (find-maximabookpage (+ 1 120) "26 Special Functions")
;; (find-maximabookpage (+ 1 121) "27 Sym")
;; (find-maximabookpage (+ 1 122) "28 Tensor")
;; (find-maximabookpage (+ 1 123) "29 Trigonometry")
;; (find-maximabookpage (+ 1 124) "30 Utils")
;; (find-maximabookpage (+ 1 125) "31 Vector")
;; (find-maximabookpage (+ 1 126) "III Installing, Resources, Misc.")
;; (find-maximabookpage (+ 1 127) "32 Installing Maxima")
;; (find-maximabookpage (+ 1 127) "32.1 Requirements")
;; (find-maximabookpage (+ 1 127) "32.2 Source Based Installation on Linux")
;; (find-maximabookpage (+ 1 127) "32.2.1 Configure")
;; (find-maximabookpage (+ 1 128) "32.2.2 Make")
;; (find-maximabookpage (+ 1 129) "32.3 Source Based Installation on Windows")
;; (find-maximabookpage (+ 1 129) "32.4 Source Based Installation on MacOSX")
;; (find-maximabookpage (+ 1 129) "List of Figures")
;; (find-maximabookpage (+ 1 130) "Index")
;; (find-maximabookpage (+ 1 132) "Bibliography")
;; «maxima-chamberlin» (to ".maxima-chamberlin")
;; https://www2.palomar.edu/users/cchamberlin/
;; https://www2.palomar.edu/users/cchamberlin/trigonometry.htm
;; https://www2.palomar.edu/users/cchamberlin/Math%20205%20pages/calculus%20III.htm
;; https://www2.palomar.edu/users/cchamberlin/Math%20205%20pages/lecture_notes_spring_2015.html
;; https://www2.palomar.edu/users/cchamberlin/Math%20205%20pages/Maxima/MaximaBook.pdf
;; «maxima-urroz» (to ".maxima-urroz")
;; (find-books "__comp/__comp.el" "maxima-urroz")
;; https://www2.palomar.edu/users/cchamberlin/Math%20205%20pages/Maxima/MaximaBook.pdf
;; (find-fline "$S/https/www2.palomar.edu/users/cchamberlin/Math%20205%20pages/Maxima/")
(code-pdf-page "urroz" "$S/https/www2.palomar.edu/users/cchamberlin/Math%20205%20pages/Maxima/MaximaBook.pdf")
(code-pdf-text "urroz" "$S/https/www2.palomar.edu/users/cchamberlin/Math%20205%20pages/Maxima/MaximaBook.pdf")
;; (find-urrozpage)
;; (find-urroztext)
;; (find-urrozpage 34 "Force floating-point")
;; (find-urroztext 34 "Force floating-point")
;; «maxima-fatemanphd» (to ".maxima-fatemanphd")
;; (find-books "__comp/__comp.el" "maxima-fatemanphd")
;; https://apps.dtic.mil/sti/pdfs/AD0740132.pdf
(code-pdf-page "fatemanphd" "$S/https/apps.dtic.mil/sti/pdfs/AD0740132.pdf")
(code-pdf-text "fatemanphd" "$S/https/apps.dtic.mil/sti/pdfs/AD0740132.pdf")
;; (find-fatemanphdpage)
;; (find-fatemanphdtext)
;; (find-fatemanphdpage 10 "Contents")
;; (find-fatemanphdtext 10 "Contents")
;; «maxima-fatemansimp» (to ".maxima-fatemansimp")
;; https://maxima.sourceforge.io/documentation.html
;; https://maxima.sourceforge.io/misc/Fateman-Salz_Simplifier_Paper.pdf
(code-pdf-page "fatemansimp" "$S/https/maxima.sourceforge.io/misc/Fateman-Salz_Simplifier_Paper.pdf")
(code-pdf-text "fatemansimp" "$S/https/maxima.sourceforge.io/misc/Fateman-Salz_Simplifier_Paper.pdf")
;; (find-fatemansimppage)
;; (find-fatemansimptext)
;; «maxima-minimal» (to ".maxima-minimal")
;; (find-es "maxima" "minimal-maxima")
;; (find-books "__comp/__comp.el" "maxima-minimal")
;; Robert Dodier: "Minimal Maxima"
;; https://maxima.sourceforge.io/docs/tutorial/en/minimal-maxima.pdf
(code-pdf-page "minimaxima" "$S/https/maxima.sourceforge.io/docs/tutorial/en/minimal-maxima.pdf")
(code-pdf-text "minimaxima" "$S/https/maxima.sourceforge.io/docs/tutorial/en/minimal-maxima.pdf")
;; (find-minimaximapage)
;; (find-minimaximatext)
;; «maxima-workbook» (to ".maxima-workbook")
;; (find-books "__comp/__comp.el" "maxima-workbook")
;; (find-es "maxima" "maxima-workbook")
;; http://roland-salz.de/html/maxima.html
;; http://roland-salz.de/Maxima_Workbook.pdf
(code-pdf-page "maximawb" "$S/http/roland-salz.de/Maxima_Workbook.pdf")
(code-pdf-text "maximawb" "$S/http/roland-salz.de/Maxima_Workbook.pdf" 20)
;; (find-maximawbpage)
;; (find-maximawbpage 5 "Contents")
;; (find-maximawbtext 5 "Contents")
;; (find-maximawbtext)
;; (find-maximawbpage (+ 20 32) "5 Graphical representation of functions")
;; (find-maximawbpage (+ 20 32) "5.1 Introduction")
;; (find-maximawbpage (+ 20 32) "5.2 Plot")
;; (find-maximawbpage (+ 20 32) "5.2.1 General")
;; (find-maximawbpage (+ 20 32) "options")
;; (find-maximawbpage (+ 20 33) "5.2.1.2 Options for both 2D and 3D plots")
;; (find-maximawbpage (+ 20 35) "5.2.1.3 Zooming the plot")
;; (find-maximawbpage (+ 20 35) "5.2.2 2D")
;; (find-maximawbpage (+ 20 35) "5.2.2.1 plot2d")
;; (find-maximawbpage (+ 20 35) "5.2.2.1.1 Explicit plot")
;; (find-maximawbpage (+ 20 36) "5.2.2.1.2 Parametric plot")
;; (find-maximawbpage (+ 20 37) "5.2.2.1.3 Discrete plot")
;; (find-maximawbpage (+ 20 38) "5.2.2.2 Implicit plot")
;; (find-maximawbpage (+ 20 39) "5.2.2.3 Contour plot")
;; (find-maximawbpage (+ 20 39) "5.2.2.4 Options for 2D")
;; (find-maximawbpage (+ 20 40) "5.2.3 3D")
;; (find-maximawbpage (+ 20 40) "5.2.3.1 plot3d")
;; (find-maximawbpage (+ 20 40) "5.2.3.1.1 Explicit plot")
;; (find-maximawbpage (+ 20 42) "5.2.3.1.2 Parametric plot")
;; (find-maximawbpage (+ 20 42) "5.2.3.2 Coordinate transformations for 3D")
;; (find-maximawbpage (+ 20 43) "5.2.3.2.1 Standard coordinate transformations")
;; (find-maximawbpage (+ 20 43) "5.2.3.2.2 User-defined coordinate transformations")
;; (find-maximawbpage (+ 20 44) "5.2.3.3 Options for 3D")
;; (find-maximawbpage (+ 20 44) "5.3 Draw")
;; (find-maximawbpage (+ 20 44) "5.3.1 Introduction")
;; (find-maximawbpage (+ 20 45) "5.3.2 General structure")
;; (find-maximawbpage (+ 20 45) "5.3.2.1 Using options")
;; (find-maximawbpage (+ 20 45) "5.3.2.1.1 General syntax")
;; (find-maximawbpage (+ 20 45) "5.3.2.1.2 Setting defaults for multiple scenes")
;; (find-maximawbpage (+ 20 45) "5.3.2.1.3 Predefined personal sets of options")
;; (find-maximawbpage (+ 20 46) "5.3.2.1.4 User_preamble")
;; (find-maximawbpage (+ 20 46) "5.3.2.1.4.1 Predefined personal user_preambles")
;; (find-maximawbpage (+ 20 46) "5.3.3 2D")
;; (find-maximawbpage (+ 20 46) "5.3.3.1 Explicit plot")
;; (find-maximawbpage (+ 20 46) "5.3.3.1.1 Piecewise defined function")
;; (find-maximawbpage (+ 20 47) "5.3.3.2 Implicit plot")
;; (find-maximawbpage (+ 20 47) "5.3.3.3 Polar plot")
;; (find-maximawbpage (+ 20 47) "5.3.4 3D")
;; (find-maximawbpage (+ 20 48) "5.3.4.1 Explicit plot")
;; (find-maximawbpage (+ 20 48) "5.3.4.2 Implicit plot")
;; (find-maximawbpage (+ 20 49) "5.3.5 List of available options")
;; (find-maximawbpage (+ 20 50) "6 Batch Processing")
;; (find-maximawbpage (+ 20 51) "III Concepts of Symbolic Computation")
;; (find-maximawbpage (+ 20 52) "7 Data types and structures")
;; (find-maximawbpage (+ 20 52) "7.1 Introduction")
;; (find-maximawbpage (+ 20 52) "7.2 Numbers")
;; (find-maximawbpage (+ 20 52) "7.2.1 Introduction")
;; (find-maximawbpage (+ 20 52) "7.2.1.1 Types")
;; (find-maximawbpage (+ 20 52) "7.2.1.2 Predicate functions")
;; (find-maximawbpage (+ 20 53) "7.2.2 Integer and rational numbers")
;; (find-maximawbpage (+ 20 53) "7.2.2.1 Representation")
;; (find-maximawbpage (+ 20 53) "7.2.2.1.1 External")
;; (find-maximawbpage (+ 20 53) "7.2.2.1.2 Internal")
;; (find-maximawbpage (+ 20 53) "7.2.2.1.2.1 Canonical rational expression (CRE)")
;; (find-maximawbpage (+ 20 53) "7.2.2.2 Predicate functions")
;; (find-maximawbpage (+ 20 54) "7.2.2.3 Type conversion")
;; (find-maximawbpage (+ 20 54) "7.2.2.3.1 Automatic")
;; (find-maximawbpage (+ 20 54) "7.2.2.3.2 Manual")
;; (find-maximawbpage (+ 20 55) "7.2.3 Floating point numbers")
;; (find-maximawbpage (+ 20 55) "7.2.3.1 Ordinary floating point numbers")
;; (find-maximawbpage (+ 20 56) "7.2.3.2 Big floating point numbers")
;; (find-maximawbpage (+ 20 56) "7.2.4 Complex numbers")
;; (find-maximawbpage (+ 20 56) "7.2.4.1 Introduction")
;; (find-maximawbpage (+ 20 56) "7.2.4.1.1 Imaginary unit")
;; (find-maximawbpage (+ 20 57) "7.2.4.1.2 Internal representation")
;; (find-maximawbpage (+ 20 57) "7.2.4.1.3 Canonical order")
;; (find-maximawbpage (+ 20 57) "7.2.4.1.4 Simplification")
;; (find-maximawbpage (+ 20 58) "7.2.4.1.5 Properties")
;; (find-maximawbpage (+ 20 58) "7.2.4.1.6 Code")
;; (find-maximawbpage (+ 20 58) "7.2.4.1.7 Generic complex data type")
;; (find-maximawbpage (+ 20 58) "7.2.4.2 Standard (rectangular) and polar form")
;; (find-maximawbpage (+ 20 58) "7.2.4.2.1 Standard (rectangular) form")
;; (find-maximawbpage (+ 20 59) "7.2.4.2.2 Polar coordinate form")
;; (find-maximawbpage (+ 20 59) "7.2.4.3 Complex conjugate")
;; (find-maximawbpage (+ 20 60) "7.2.4.3.1 Internal representation")
;; (find-maximawbpage (+ 20 60) "7.2.4.4 Predicate function")
;; (find-maximawbpage (+ 20 61) "7.3 Boolean values")
;; (find-maximawbpage (+ 20 61) "7.4 Constant")
;; (find-maximawbpage (+ 20 61) "7.5 Sharing of data")
;; (find-maximawbpage (+ 20 62) "8 List, matrix, structure")
;; (find-maximawbpage (+ 20 62) "8.1 List")
;; (find-maximawbpage (+ 20 62) "8.1.1 makelist")
;; (find-maximawbpage (+ 20 62) "8.1.2 create_list")
;; (find-maximawbpage (+ 20 62) "8.2 Matrix")
;; (find-maximawbpage (+ 20 62) "8.3 Structure")
;; (find-maximawbpage (+ 20 63) "9 Expression")
;; (find-maximawbpage (+ 20 63) "9.1 General definitions")
;; (find-maximawbpage (+ 20 63) "9.2 Forms of representation")
;; (find-maximawbpage (+ 20 63) "9.2.1 User visible form (UVF)")
;; (find-maximawbpage (+ 20 64) "9.2.2 General internal form (GIF)")
;; (find-maximawbpage (+ 20 65) "9.2.3 Canonical rational expression (CRE)")
;; (find-maximawbpage (+ 20 65) "9.3 Canonical order")
;; (find-maximawbpage (+ 20 66) "9.4 Noun and verb")
;; (find-maximawbpage (+ 20 66) "9.5 Equation")
;; (find-maximawbpage (+ 20 66) "9.6 Reference to subexpression")
;; (find-maximawbpage (+ 20 66) "9.6.1 Identify and pick out subexpression")
;; (find-maximawbpage (+ 20 67) "9.6.2 Substitute subexpression")
;; (find-maximawbpage (+ 20 67) "9.7 Manipulate expression")
;; (find-maximawbpage (+ 20 67) "9.7.1 Substitute pattern")
;; (find-maximawbpage (+ 20 67) "9.7.1.1 subst: substitute explicite pattern")
;; (find-maximawbpage (+ 20 69) "9.7.1.2 ratsubst: substitute implicit mathematical pattern")
;; (find-maximawbpage (+ 20 69) "9.7.2 Box and rembox")
;; (find-maximawbpage (+ 20 71) "10 Operators")
;; (find-maximawbpage (+ 20 71) "10.1 Defining and using operators")
;; (find-maximawbpage (+ 20 71) "10.1.1 Function notation of an operator")
;; (find-maximawbpage (+ 20 71) "10.1.2 Miscellaneous")
;; (find-maximawbpage (+ 20 71) "10.2 System defined operators")
;; (find-maximawbpage (+ 20 71) "10.2.1 Identity operators and functions")
;; (find-maximawbpage (+ 20 71) "10.2.1.1 Equation operator")
;; (find-maximawbpage (+ 20 72) "10.2.1.2 Inequation operator")
;; (find-maximawbpage (+ 20 72) "10.2.1.3 equal, notequal")
;; (find-maximawbpage (+ 20 74) "10.2.1.4 is, is(a=b), is(equal(a,b))")
;; (find-maximawbpage (+ 20 74) "10.2.2 Relational operators")
;; (find-maximawbpage (+ 20 75) "10.2.3 Logical (Boolean) operators")
;; (find-maximawbpage (+ 20 76) "11 Evaluation")
;; (find-maximawbpage (+ 20 76) "11.1 Introduction to evaluation")
;; (find-maximawbpage (+ 20 76) "11.1.1 Stavros' warning note about ev and quote-quote")
;; (find-maximawbpage (+ 20 77) "11.2 Function ev")
;; (find-maximawbpage (+ 20 79) "11.3 Quote-quote operator 0 0")
;; (find-maximawbpage (+ 20 79) "11.4 Substitution")
;; (find-maximawbpage (+ 20 80) "11.4.1 Substituting values for variables")
;; (find-maximawbpage (+ 20 81) "12 Simplification")
;; (find-maximawbpage (+ 20 81) "12.1 Properties for simplification")
;; (find-maximawbpage (+ 20 81) "12.2 General simplification")
;; (find-maximawbpage (+ 20 81) "12.2.1 Conversion between (complex) exponentials and circular/hyperbolic functions")
;; (find-maximawbpage (+ 20 82) "12.3 Trigonometric simplification")
;; (find-maximawbpage (+ 20 82) "12.4 Own simplification functions")
;; (find-maximawbpage (+ 20 82) "12.4.1 Apply2Part")
;; (find-maximawbpage (+ 20 83) "12.4.2 ChangeSign")
;; (find-maximawbpage (+ 20 83) "12.4.3 FactorTerms")
;; (find-maximawbpage (+ 20 84) "12.4.4 PullFactorOut")
;; (find-maximawbpage (+ 20 86) "13 Knowledge database system")
;; (find-maximawbpage (+ 20 86) "13.1 Facts and contexts: The general system")
;; (find-maximawbpage (+ 20 86) "13.1.1 User interface")
;; (find-maximawbpage (+ 20 86) "13.1.1.1 Introduction")
;; (find-maximawbpage (+ 20 88) "13.1.1.2 Functions and system variables")
;; (find-maximawbpage (+ 20 89) "13.1.2 Implementation")
;; (find-maximawbpage (+ 20 89) "13.1.2.1 Internal data structure")
;; (find-maximawbpage (+ 20 89) "13.1.2.2 Notes on the program code")
;; (find-maximawbpage (+ 20 89) "13.2 Values, properties and assumptions")
;; (find-maximawbpage (+ 20 90) "13.3 MaximaL Properties")
;; (find-maximawbpage (+ 20 90) "13.3.1 Introduction")
;; (find-maximawbpage (+ 20 90) "13.3.2 System-declared properties")
;; (find-maximawbpage (+ 20 91) "13.3.3 User-declared properties")
;; (find-maximawbpage (+ 20 91) "13.3.3.1 Declaration, information, removal")
;; (find-maximawbpage (+ 20 91) "13.3.3.2 Properties of variables")
;; (find-maximawbpage (+ 20 93) "13.3.3.3 Properties of functions")
;; (find-maximawbpage (+ 20 94) "13.3.4 User-defined properties")
;; (find-maximawbpage (+ 20 95) "13.3.5 Implementation")
;; (find-maximawbpage (+ 20 95) "13.4 Assumptions")
;; (find-maximawbpage (+ 20 95) "13.4.1 User interface")
;; (find-maximawbpage (+ 20 95) "13.4.1.1 Introduction")
;; (find-maximawbpage (+ 20 96) "13.4.1.2 Functions and system variables for assumptions")
;; (find-maximawbpage (+ 20 98) "13.4.2 Implementation")
;; (find-maximawbpage (+ 20 99) "14 Patterns and rules")
;; (find-maximawbpage (+ 20 99) "14.1 Introduction")
;; (find-maximawbpage (+ 20 99) "14.1.1 What pattern matching is and how it works in Maxima")
;; «maxima-advfree» (to ".maxima-advfree")
;; (find-books "__comp/__comp.el" "maxima-advfree")
;; (find-es "maxima" "advfree")
;; http://www.five-dimensions.org/Textbooks/
;; http://www.five-dimensions.org/Textbooks/adventures.pdf
;; Justin R. Smith: "Adventures with free Mathematical Software"
(code-pdf-page "advfree" "$S/http/www.five-dimensions.org/Textbooks/adventures.pdf")
(code-pdf-text "advfree" "$S/http/www.five-dimensions.org/Textbooks/adventures.pdf" 18)
;; (find-advfreepage)
;; (find-advfreetext)
;; (find-advfreepage (+ 16 16) "we need if-statements")
;; (find-advfreetext (+ 16 16) "we need if-statements")
;; (find-advfreepage (+ 18 30) "we need if-statements")
;; (find-advfreetext (+ 18 30) "we need if-statements")
;; (find-advfreepage (+ 16 41) "plotdf")
;; (find-advfreetext (+ 16 41) "plotdf")
;; (find-advfreepage (+ 18 39) "plotdf")
;; (find-advfreetext (+ 18 39) "plotdf")
;; «maxima-diffeqs» (to ".maxima-diffeqs")
;; (find-es "maxima" "diffeqs-maxima")
;; https://lindnerdrwg.github.io/DifferentialEquationsMaxima.pdf
(code-pdf-page "diffeqsmaxima" "$S/https/lindnerdrwg.github.io/DifferentialEquationsMaxima.pdf")
(code-pdf-text8 "diffeqsmaxima" "$S/https/lindnerdrwg.github.io/DifferentialEquationsMaxima.pdf")
;; (find-diffeqsmaximapage)
;; (find-diffeqsmaximatext)
;; (find-diffeqsmaximapage (+ 1 4) "1 What is an Ordinary Differential Equation?")
;; (find-diffeqsmaximapage (+ 1 4) "1.1 Definition of ODE")
;; (find-diffeqsmaximapage (+ 1 8) "1.2 Existence-Uniqueness Theorem - Picard iteration")
;; (find-diffeqsmaximapage (+ 1 13) "2 Analytical Solution Methods")
;; (find-diffeqsmaximapage (+ 1 13) "2.1 the case y 0 = f (x) : direct integration of ODE")
;; (find-diffeqsmaximapage (+ 1 17) "2.2 the case y 0 = f (y)")
;; (find-diffeqsmaximapage (+ 1 20) "2.3 the case y 0 = f (x) · g(y) : Separation of Variables")
;; (find-diffeqsmaximatext (+ 1 20) "odefxgy")
;; (find-diffeqsmaximapage (+ 1 24) "2.4 the case y 0 = f (x) · y + g(x) : linear ODE")
;; (find-diffeqsmaximapage (+ 1 28) "2.5 the case fx + fy · y 0 = 0 : exact ODE")
;; (find-diffeqsmaximapage (+ 1 33) "2.6 the case y 0 = f ( xy ) : substitutions")
;; (find-diffeqsmaximapage (+ 1 36) "3 Intermezzo: iterate")
;; (find-diffeqsmaximapage (+ 1 36) "3.1 iterate by hand")
;; (find-diffeqsmaximapage (+ 1 37) "3.2 iterate by iterate")
;; (find-diffeqsmaximapage (+ 1 40) "3.3 First Applications of iterate")
;; (find-diffeqsmaximapage (+ 1 45) "3.4 Implict differentation and the Taylor method for ODE's")
;; (find-diffeqsmaximapage (+ 1 51) "4 Numerical Solution Methods for IVP")
;; (find-diffeqsmaximapage (+ 1 52) "4.1 RK1 alias the Euler Method")
;; (find-diffeqsmaximapage (+ 1 59) "4.2 RK2h alias Heun's Method")
;; (find-diffeqsmaximapage (+ 1 61) "4.3 RK2m alias the Midpoint Method")
;; (find-diffeqsmaximapage (+ 1 63) "4.4 RK4 alias the classic Runge-Kutta method")
;; (find-diffeqsmaximapage (+ 1 68) "5 Systems of IVP's")
;; (find-diffeqsmaximapage (+ 1 69) "5.1 Solving IVP systems")
;; (find-diffeqsmaximapage (+ 1 73) "5.2 IVP of 2nd Order")
;; (find-diffeqsmaximapage (+ 1 81) "6 Boundary Value Problems - Numerical Methods")
;; (find-diffeqsmaximapage (+ 1 81) "6.1 Shooting Method")
;; (find-diffeqsmaximapage (+ 1 91) "6.2 Finite Difference Method")
;; (find-diffeqsmaximapage (+ 1 98) "7 Appendix: Collection of Source Code")
;; (find-diffeqsmaximapage (+ 1 104) "8 Bibliography")
;; «maxima-vallejomor» (to ".maxima-vallejomor")
;; José A Vallejo, Antonio Morante: "Matemáticas Básicas (con Software Libre)"
;; https://arxiv.org/abs/2002.11280
;; https://arxiv.org/pdf/2002.11280.pdf
(code-pdf-page "vallejomor" "$S/https/arxiv.org/pdf/2002.11280.pdf")
(code-pdf-text "vallejomor" "$S/https/arxiv.org/pdf/2002.11280.pdf")
;; (find-vallejomorpage)
;; (find-vallejomortext)
;; «maxima-by-example» (to ".maxima-by-example")
;; (find-es "maxima" "maxima-by-example")
;; (find-angg ".emacs.papers" "maxima-by-example")
;; «prog-1» (to ".prog-1")
;; (find-books "__comp/__comp.el" "prog-1")
;; <prog1-lago>
;; https://www.ime.usp.br/~slago/slago-C.pdf
(code-pdf-page "prog1lago" "$S/https/www.ime.usp.br/~slago/slago-C.pdf")
(code-pdf-text "prog1lago" "$S/https/www.ime.usp.br/~slago/slago-C.pdf" 6)
;; (find-prog1lagopage)
;; (find-prog1lagotext)
;; (find-prog1lagopage (+ 6 1) "1. INTRODUÇÃO")
;; (find-prog1lagopage (+ 6 1) "1.1. A Origem da Linguagem C")
;; (find-prog1lagopage (+ 6 1) "1.2. O Ambiente Turbo C")
;; (find-prog1lagopage (+ 6 2) "1.3. A Estrutura Básica dos Programas")
;; (find-prog1lagopage (+ 6 4) "1.4. Tipos de Dados")
;; (find-prog1lagopage (+ 6 5) "1.4.1. Tipos de Dados Modificados")
;; (find-prog1lagopage (+ 6 6) "1.5. Entrada e Saída de Dados Formatada")
;; (find-prog1lagopage (+ 6 7) "1.5.1. Formatação de Campos de Exibição")
;; (find-prog1lagopage (+ 6 8) "1.6. Operadores Aritméticos")
;; (find-prog1lagopage (+ 6 9) "2. COMANDOS DE DECISÃO")
;; (find-prog1lagopage (+ 6 9) "2.1. Expressões Lógicas")
;; (find-prog1lagopage (+ 6 10) "2.2. Decisão Simples")
;; (find-prog1lagopage (+ 6 13) "2.2.1. Operador condicional")
;; (find-prog1lagopage (+ 6 14) "2.2.2. Condicionais Aninhados e Encadeados")
;; (find-prog1lagopage (+ 6 15) "2.3. Decisão Múltipla")
;; (find-prog1lagopage (+ 6 18) "3. COMANDOS DE REPETIÇÃO")
;; (find-prog1lagopage (+ 6 18) "3.1. Expressões Compactas")
;; (find-prog1lagopage (+ 6 18) "3.1.1. Operadores Aritméticos de Atribuição")
;; (find-prog1lagopage (+ 6 19) "3.1.2. Incremento e Decremento")
;; (find-prog1lagopage (+ 6 20) "3.2. Repetição com Contador")
;; (find-prog1lagopage (+ 6 23) "3.3. Repetição com Precondição")
;; (find-prog1lagopage (+ 6 25) "3.3.1. Deixando rastros na Tela")
;; (find-prog1lagopage (+ 6 26) "3.4. Repetição com Poscondição")
;; (find-prog1lagopage (+ 6 29) "3.5. Interrompendo uma Repetição")
;; (find-prog1lagopage (+ 6 31) "4. MACROS E FUNÇÕES")
;; (find-prog1lagopage (+ 6 31) "4.1. Preprocessamento")
;; (find-prog1lagopage (+ 6 31) "4.1.1. A diretiva #define")
;; (find-prog1lagopage (+ 6 33) "4.1.2. A diretiva #include")
;; (find-prog1lagopage (+ 6 34) " 4.2. Definição e Uso de Funções")
;; (find-prog1lagopage (+ 6 35) "4.2.1. Funções que não Devolvem Resposta")
;; (find-prog1lagopage (+ 6 38) "4.2.2. Funções que Devolvem Resposta")
;; (find-prog1lagopage (+ 6 40) "4.3. Classes de Armazenamento")
;; (find-prog1lagopage (+ 6 42) "4.4. Recursividade")
;; (find-prog1lagopage (+ 6 44) "4.4.1. Funções Recursivas")
;; (find-prog1lagopage (+ 6 46) "4.4.2. Procedimentos Recursivos")
;; (find-prog1lagopage (+ 6 48) "5. VETORES, STRINGS E MATRIZES")
;; (find-prog1lagopage (+ 6 48) "5.1. Vetores")
;; (find-prog1lagopage (+ 6 50) "5.1.1. Inicialização de Vetores")
;; (find-prog1lagopage (+ 6 52) "5.1.2. Parâmetros do Tipo Vetor")
;; (find-prog1lagopage (+ 6 55) "5.2. Strings")
;; (find-prog1lagopage (+ 6 56) "5.2.1. Inicialização de Strings")
;; (find-prog1lagopage (+ 6 57) "5.2.2. Manipulação de Strings")
;; (find-prog1lagopage (+ 6 60) "5.3. Matrizes")
;; (find-prog1lagopage (+ 6 62) "5.3.1. Inicialização de Matrizes")
;; (find-prog1lagopage (+ 6 63) "5.3.2. Passando Matrizes a Funções")
;; (find-prog1lagopage (+ 6 65) "5.4. Métodos de Busca")
;; (find-prog1lagopage (+ 6 65) "5.4.1. Busca Linear")
;; (find-prog1lagopage (+ 6 67) "5.4.2. Busca Binária")
;; (find-prog1lagopage (+ 6 71) "5.5. Métodos de Ordenação")
;; (find-prog1lagopage (+ 6 71) "5.5.1. Ordenação por Trocas")
;; (find-prog1lagopage (+ 6 73) "5.5.2. Ordenação por Seleção")
;; (find-prog1lagopage (+ 6 75) "5.5.3. Ordenação por Inserção")
;; (find-prog1lagopage (+ 6 77) "6. ESTRUTURAS E UNIÕES")
;; (find-prog1lagopage (+ 6 77) "6.1. Estruturas")
;; (find-prog1lagopage (+ 6 79) "6.1.1. Inicialização e Aninhamento")
;; (find-prog1lagopage (+ 6 81) "6.1.2. Vetores de Estruturas")
;; (find-prog1lagopage (+ 6 82) "6.1.3. Ordenação e Busca em Tabelas")
;; (find-prog1lagopage (+ 6 84) "6.2. Uniões")
;; (find-prog1lagopage (+ 6 84) "6.2.1. Uniões Etiquetadas")
;; (find-prog1lagopage (+ 6 86) "6.3. Campos de Bits")
;; (find-prog1lagopage (+ 6 87) "6.3.1. Acessando um Dispositivo de Hardware")
;; (find-prog1lagopage (+ 6 89) "6.3.2. Economizando Espaço de Armazenamento")
;; (find-prog1lagopage (+ 6 92) "7. PONTEIROS")
;; (find-prog1lagopage (+ 6 92) "7.1. Definição e Uso")
;; (find-prog1lagopage (+ 6 94) "7.1.1. Passagem por Referência")
;; (find-prog1lagopage (+ 6 96) "7.1.2. Ponteiros para Ponteiros")
;; (find-prog1lagopage (+ 6 97) "7.1.3. Aritmética de ponteiros")
;; (find-prog1lagopage (+ 6 99) "7.2. Ponteiros e Vetores")
;; (find-prog1lagopage (+ 6 100) "7.2.1. Vetores de Strings")
;; (find-prog1lagopage (+ 6 101) "7.2.2. Argumentos da Linha de Comando")
;; (find-prog1lagopage (+ 6 103) "7.3. Ponteiros e Funções")
;; (find-prog1lagopage (+ 6 103) "7.3.1. Funções que Devolvem Ponteiros")
;; (find-prog1lagopage (+ 6 104) "7.3.2. Ponteiros para Funções")
;; (find-prog1lagopage (+ 6 107) "7.4. Ponteiros e Estruturas")
;; (find-prog1lagopage (+ 6 109) "7.4.1. Alocação Dinâmica de Memória")
;; (find-prog1lagopage (+ 6 112) "7.4.2. Listas Encadeadas")
;; (find-prog1lagopage (+ 6 115) "7.4.3. Tratamento Recursivo de Listas")
;; (find-prog1lagopage (+ 6 119) "8. ARQUIVOS")
;; (find-prog1lagopage (+ 6 119) "8.1. Ponteiros de Arquivo")
;; (find-prog1lagopage (+ 6 120) "8.2. Arquivos-Padrão")
;; (find-prog1lagopage (+ 6 121) "8.2.1. Redirecionamento de E/S padrão")
;; (find-prog1lagopage (+ 6 122) "8.3. Operações Básicas")
;; (find-prog1lagopage (+ 6 122) "8.3.1. Abertura de Arquivo")
;; (find-prog1lagopage (+ 6 123) "8.3.2. Fechamento de Arquivo")
;; (find-prog1lagopage (+ 6 124) "8.3.3. Verificação de Final de Arquivo")
;; (find-prog1lagopage (+ 6 125) "8.4. Modo Texto versus Modo Binário")
;; (find-prog1lagopage (+ 6 125) "8.4.1. E/S caracter")
;; (find-prog1lagopage (+ 6 127) "8.4.2. E/S Formatada")
;; (find-prog1lagopage (+ 6 128) "8.4.3. E/S Binária")
;; (find-prog1lagopage (+ 6 130) "TABELA ASCII")
;; (find-prog1lagopage (+ 6 131) "BIBLIOGRAFIA")
;; <prog1-martinez>
;; https://www.facom.ufms.br/~montera/progiv2.pdf
(code-pdf-page "prog1martinez" "$S/https/www.facom.ufms.br/~montera/progiv2.pdf")
(code-pdf-text "prog1martinez" "$S/https/www.facom.ufms.br/~montera/progiv2.pdf" 7)
;; (find-prog1martinezpage)
;; (find-prog1martineztext)
;; (find-prog1martinezpage (+ 7 1) "1 Breve história da computação")
;; (find-prog1martinezpage (+ 7 1) "1.1 Pré-história")
;; (find-prog1martinezpage (+ 7 5) "1.2 Século XX")
;; (find-prog1martinezpage (+ 7 5) "1.2.1 Computadores Eletromecânicos")
;; (find-prog1martinezpage (+ 7 7) "1.2.2 Computadores Eletrônicos")
;; (find-prog1martinezpage (+ 7 21) "2 Introdução à computação")
;; (find-prog1martinezpage (+ 7 21) "2.1 Contextualização")
;; (find-prog1martinezpage (+ 7 22) "2.2 Arquitetura de von Neumann")
;; (find-prog1martinezpage (+ 7 24) "2.3 Algoritmos e programas")
;; (find-prog1martinezpage (+ 7 26) "2.3.1 Algoritmos e resolução de problemas")
;; (find-prog1martinezpage (+ 7 27) "2.3.2 Resolução de problemas e abstração")
;; (find-prog1martinezpage (+ 7 28) "2.3.3 Algoritmos e computadores")
;; (find-prog1martinezpage (+ 7 31) "3 Dicas iniciais")
;; (find-prog1martinezpage (+ 7 31) "3.1 Interface do sistema operacional")
;; (find-prog1martinezpage (+ 7 36) "3.2 Compilador")
;; (find-prog1martinezpage (+ 7 37) "3.3 Emacs")
;; (find-prog1martinezpage (+ 7 41) "4 Primeiros programas")
;; (find-prog1martinezpage (+ 7 41) "4.1 Digitando")
;; (find-prog1martinezpage (+ 7 41) "4.2 Compilando e executando")
;; (find-prog1martinezpage (+ 7 42) "4.3 Olhando o primeiro programa mais de perto")
;; (find-prog1martinezpage (+ 7 43) "4.4 Próximo programa")
;; (find-prog1martinezpage (+ 7 44) "4.5 Documentação")
;; (find-prog1martinezpage (+ 7 45) "4.6 Entrada e saída")
;; (find-prog1martinezpage (+ 7 49) "5 Estruturas condicionais")
;; (find-prog1martinezpage (+ 7 49) " 5.1 Estrutura condicional simples")
;; (find-prog1martinezpage (+ 7 50) "5.2 Estrutura condicional composta")
;; (find-prog1martinezpage (+ 7 51) "5.2.1 Aplicação: troca de conteúdos")
;; (find-prog1martinezpage (+ 7 52) "5.3 Revisão de números inteiros")
;; (find-prog1martinezpage (+ 7 56) "5.3.1 Representação de números inteiros")
;; (find-prog1martinezpage (+ 7 59) "6 Estrutura de repetição while")
;; (find-prog1martinezpage (+ 7 59) "6.1 Motivação")
;; (find-prog1martinezpage (+ 7 60) "6.2 Estrutura de repetição while")
;; (find-prog1martinezpage (+ 7 63) "7 Expressões com inteiros")
;; (find-prog1martinezpage (+ 7 63) "7.1 Expressões aritméticas")
;; (find-prog1martinezpage (+ 7 64) "7.2 Expressões relacionais")
;; (find-prog1martinezpage (+ 7 65) "7.3 Expressões lógicas")
;; (find-prog1martinezpage (+ 7 73) "8 Outras estruturas de repetição")
;; (find-prog1martinezpage (+ 7 73) "8.1 Estrutura de repetição for")
;; (find-prog1martinezpage (+ 7 75) "8.2 Estrutura de repetição do-while")
;; (find-prog1martinezpage (+ 7 79) "9 Números com ponto flutuante")
;; (find-prog1martinezpage (+ 7 79) "9.1 Constantes e variáveis do tipo ponto flutuante")
;; (find-prog1martinezpage (+ 7 81) "9.2 Expressões aritméticas")
;; (find-prog1martinezpage (+ 7 89) "10 Caracteres")
;; (find-prog1martinezpage (+ 7 89) "10.1 Representação gráfica")
;; (find-prog1martinezpage (+ 7 91) "10.2 Constantes e variáveis")
;; (find-prog1martinezpage (+ 7 93) "10.3 Expressões com caracteres")
;; (find-prog1martinezpage (+ 7 95) "11 Tipos primitivos de dados")
;; (find-prog1martinezpage (+ 7 95) "11.1 Tipos inteiros")
;; (find-prog1martinezpage (+ 7 101) "11.2 Números com ponto flutuante")
;; (find-prog1martinezpage (+ 7 102) "11.3 Caracteres")
;; (find-prog1martinezpage (+ 7 106) "11.4 Conversão de tipos")
;; (find-prog1martinezpage (+ 7 108) "11.5 Tipos de dados definidos pelo programador")
;; (find-prog1martinezpage (+ 7 109) "11.6 Operador sizeof")
;; (find-prog1martinezpage (+ 7 110) "11.7 Exercícios")
;; (find-prog1martinezpage (+ 7 113) "12 Vetores")
;; (find-prog1martinezpage (+ 7 113) "12.1 Motivação")
;; (find-prog1martinezpage (+ 7 115) "12.2 Definição")
;; (find-prog1martinezpage (+ 7 116) "12.3 Declaração com inicialização")
;; (find-prog1martinezpage (+ 7 117) "12.4 Exemplo com vetores")
;; (find-prog1martinezpage (+ 7 118) "12.5 Macros para constantes")
;; (find-prog1martinezpage (+ 7 125) "13 Cadeias de caracteres")
;; (find-prog1martinezpage (+ 7 125) "13.1 Literais")
;; (find-prog1martinezpage (+ 7 126) "13.2 Vetores de caracteres")
;; (find-prog1martinezpage (+ 7 127) "13.3 Cadeias de caracteres")
;; (find-prog1martinezpage (+ 7 133) "14 Matrizes")
;; (find-prog1martinezpage (+ 7 133) "14.1 Definição, declaração e uso")
;; (find-prog1martinezpage (+ 7 135) "14.2 Declaração e inicialização simultâneas")
;; (find-prog1martinezpage (+ 7 136) "14.3 Exemplo")
;; (find-prog1martinezpage (+ 7 143) "15 Registros")
;; (find-prog1martinezpage (+ 7 143) "15.1 Definição")
;; (find-prog1martinezpage (+ 7 146) "15.2 Declaração e inicialização simultâneas")
;; (find-prog1martinezpage (+ 7 147) "15.3 Operações sobre registros")
;; (find-prog1martinezpage (+ 7 148) "15.4 Exemplo")
;; (find-prog1martinezpage (+ 7 151) "16 Vetores, matrizes e registros")
;; (find-prog1martinezpage (+ 7 151) "16.1 Variáveis compostas homogêneas de registros")
;; (find-prog1martinezpage (+ 7 155) "16.2 Registros contendo variáveis compostas homogêneas")
;; (find-prog1martinezpage (+ 7 157) "16.3 Registros contendo registros")
;; (find-prog1martinezpage (+ 7 163) "17 Introdução às funções")
;; (find-prog1martinezpage (+ 7 163) "17.1 Noções iniciais")
;; (find-prog1martinezpage (+ 7 168) "17.2 Definição e chamada de funções")
;; (find-prog1martinezpage (+ 7 171) "17.3 Finalização de programas")
;; (find-prog1martinezpage (+ 7 172) "17.4 Exemplo")
;; (find-prog1martinezpage (+ 7 174) "17.5 Declaração de funções")
;; (find-prog1martinezpage (+ 7 181) "18 Argumentos e parâmetros de funções")
;; (find-prog1martinezpage (+ 7 181) " 18.1 Argumentos e parâmetros")
;; (find-prog1martinezpage (+ 7 183) "18.2 Escopo de dados e de funções")
;; (find-prog1martinezpage (+ 7 187) "19 Funções e vetores")
;; (find-prog1martinezpage (+ 7 187) "19.1 Vetores como argumentos de funções")
;; (find-prog1martinezpage (+ 7 188) "19.2 Vetores são parâmetros passados por referência")
;; (find-prog1martinezpage (+ 7 189) "19.3 Vetores como parâmetros com dimensões omitidas")
;; (find-prog1martinezpage (+ 7 193) "20 Funções e matrizes")
;; (find-prog1martinezpage (+ 7 193) "20.1 Matrizes")
;; (find-prog1martinezpage (+ 7 194) "20.2 Matrizes como parâmetros com uma dimensão omitida")
;; (find-prog1martinezpage (+ 7 199) "21 Funções e registros")
;; (find-prog1martinezpage (+ 7 199) "21.1 Tipo registro")
;; (find-prog1martinezpage (+ 7 201) "21.2 Registros e passagem por cópia")
;; (find-prog1martinezpage (+ 7 203) "21.3 Registros e passagem por referência")
;; (find-prog1martinezpage (+ 7 205) "21.4 Funções que devolvem registros")
;; (find-prog1martinezpage (+ 7 209) "22 Biblioteca padrão")
;; (find-prog1martinezpage (+ 7 209) "22.1 Qualificadores de tipos")
;; (find-prog1martinezpage (+ 7 210) "22.2 Arquivo-cabeçalho")
;; (find-prog1martinezpage (+ 7 213) "22.3 Arquivos-cabeçalhos da biblioteca padrão")
;; (find-prog1martinezpage (+ 7 213) "22.3.1 Diagnósticos")
;; (find-prog1martinezpage (+ 7 214) "22.3.2 Manipulação, teste e conversão de caracteres")
;; (find-prog1martinezpage (+ 7 215) "22.3.3 Erros")
;; (find-prog1martinezpage (+ 7 216) "22.3.4 Características dos tipos com ponto flutuante")
;; (find-prog1martinezpage (+ 7 216) "22.3.5 Localização")
;; (find-prog1martinezpage (+ 7 217) "22.3.6 Matemática")
;; (find-prog1martinezpage (+ 7 220) "22.3.7 Saltos não-locais")
;; (find-prog1martinezpage (+ 7 221) "22.3.8 Manipulação de sinais")
;; (find-prog1martinezpage (+ 7 222) "22.3.9 Número variável de argumentos")
;; (find-prog1martinezpage (+ 7 222) "22.3.10 Definições comuns")
;; (find-prog1martinezpage (+ 7 222) "22.3.11 Entrada e saída")
;; (find-prog1martinezpage (+ 7 223) "22.3.12 Utilitários gerais")
;; (find-prog1martinezpage (+ 7 225) "22.3.13 Manipulação de cadeias")
;; (find-prog1martinezpage (+ 7 227) "22.3.14 Data e hora")
;; (find-prog1martinezpage (+ 7 229) "23 Depuração de programas")
;; (find-prog1martinezpage (+ 7 229) "23.1 Depurador GDB")
;; (find-prog1martinezpage (+ 7 230) "23.2 Primeiro contato")
;; (find-prog1martinezpage (+ 7 231) "23.3 Sintaxe dos comandos do GDB")
;; (find-prog1martinezpage (+ 7 232) "23.4 Pontos de parada")
;; (find-prog1martinezpage (+ 7 234) "23.5 Programa fonte")
;; (find-prog1martinezpage (+ 7 235) "23.6 Verificação de dados")
;; (find-prog1martinezpage (+ 7 236) "23.7 Alteração de dados durante a execução")
;; (find-prog1martinezpage (+ 7 236) "23.8 Resumo dos comandos")
;; (find-prog1martinezpage (+ 7 237) "23.9 Exemplos de execução")
;; (find-prog1martinezpage (+ 7 249) "24 Pré-processador")
;; (find-prog1martinezpage (+ 7 249) "24.1 Funcionamento")
;; (find-prog1martinezpage (+ 7 250) "24.2 Diretivas de pré-processamento")
;; (find-prog1martinezpage (+ 7 251) "24.3 Definições de macros")
;; (find-prog1martinezpage (+ 7 252) "24.4 Inclusão de arquivos-cabeçalhos")
;; (find-prog1martinezpage (+ 7 254) "24.5 Compilação condicional")
;; (find-prog1martinezpage (+ 7 256) "24.6 Outras diretivas")
;; <prog1-ciferri>
;; (find-books "__comp/__comp.el" "prog1-ciferri")
(code-pdf-page "prog1ciferri" "~/books/__comp/ciferri__programacao_de_computadores.pdf")
(code-pdf-text "prog1ciferri" "~/books/__comp/ciferri__programacao_de_computadores.pdf" 1)
;; (find-prog1ciferripage)
;; (find-prog1ciferripage 5 "Contents")
;; (find-prog1ciferripage (+ 1 189) "Index")
;; (find-prog1ciferritext "")
;; <prog1-feofiloff>
;; (find-books "__comp/__comp.el" "prog1-feofiloff")
(code-pdf-page "prog1feofiloff" "~/books/__comp/feofiloff__algoritmos_em_linguagem_C.pdf")
(code-pdf-text "prog1feofiloff" "~/books/__comp/feofiloff__algoritmos_em_linguagem_C.pdf" 1)
;; (find-prog1feofiloffpage)
;; (find-prog1feofiloffpage 1 "Contents")
;; (find-prog1feofiloffpage (+ 1 189) "Index")
;; (find-prog1feofilofftext "")
;; <prog1-schildt>
;; (find-books "__comp/__comp.el" "prog1-schildt")
(code-pdf-page "prog1schildt" "~/books/__comp/schildt__C_the_complete_reference.pdf")
(code-pdf-text "prog1schildt" "~/books/__comp/schildt__C_the_complete_reference.pdf" 1)
;; (find-prog1schildtpage)
;; (find-prog1schildtpage 6 "Contents")
;; (find-prog1schildtpage (+ 1 189) "Index")
;; (find-prog1schildttext "")
;; <prog1-szwarcfiter>
;; (find-books "__comp/__comp.el" "prog1-szwarcfiter")
(code-pdf-page "prog1szwarcfiter" "~/books/__comp/szwarcfiter__estruturas_de_dados_e_seus_algoritmos.pdf")
(code-pdf-text "prog1szwarcfiter" "~/books/__comp/szwarcfiter__estruturas_de_dados_e_seus_algoritmos.pdf" 1)
;; (find-prog1szwarcfiterpage)
;; (find-prog1szwarcfiterpage 7 "Contents")
;; (find-prog1szwarcfiterpage (+ 1 189) "Index")
;; (find-prog1szwarcfitertext "")
;; «ocaml» (to ".ocaml")
;; (find-books "__comp/__comp.el" "ocaml")
;; https://ocaml.org/learn/books.html
;; https://stackoverflow.com/tags/ocaml/info
;; https://stackoverflow.com/questions/7582388/looking-for-ocaml-ide
(code-pdf-page "realworldocaml" "~/books/__comp/minsky_madhavapeddy_hickey__real_world_ocaml.pdf")
(code-pdf-text "realworldocaml" "~/books/__comp/minsky_madhavapeddy_hickey__real_world_ocaml.pdf" 24)
;; (find-realworldocamlpage)
;; (find-realworldocamlpage 7 "Contents")
;; (find-realworldocamltext 7 "Contents")
;; (find-realworldocamlpage (+ 24 1) "Language concepts")
;; (find-realworldocamltext (+ 24 1) "Language concepts")
;; (find-realworldocamlpage (+ 24 271) "14. Command-Line Parsing.")
;; (find-realworldocamlpage (+ 24 272) "Basic Command-Line Parsing")
;; (find-realworldocamlpage (+ 24 272) "Anonymous Arguments")
;; (find-realworldocamlpage (+ 24 273) "Defining Basic Commands")
;; (find-realworldocamlpage (+ 24 273) "Running Basic Commands")
;; (find-realworldocamlpage (+ 24 275) "Argument Types")
;; (find-realworldocamlpage (+ 24 276) "Defining Custom Argument Types")
;; (find-realworldocamlpage (+ 24 277) "Optional and Default Arguments")
;; (find-realworldocamlpage (+ 24 279) "Sequences of Arguments")
;; (find-realworldocamlpage (+ 24 280) "Adding Labeled Flags to the Command Line")
;; (find-realworldocamlpage (+ 24 282) "Grouping Subcommands Together")
;; (find-realworldocamlpage (+ 24 284) "Advanced Control over Parsing")
;; (find-realworldocamlpage (+ 24 285) "The Types Behind Command.Spec")
;; (find-realworldocamlpage (+ 24 286) "Composing Specification Fragments Together")
;; (find-realworldocamlpage (+ 24 287) "Prompting for Interactive Input")
;; (find-realworldocamlpage (+ 24 289) "Adding Labeled Arguments to Callbacks")
;; (find-realworldocamlpage (+ 24 290) "Command-Line Autocompletion with bash")
;; (find-realworldocamlpage (+ 24 290) "Generating Completion Fragments from Command")
;; (find-realworldocamlpage (+ 24 291) "Installing the Completion Fragment")
;; (find-realworldocamlpage (+ 24 292) "Alternative Command-Line Parsers")
;; (find-realworldocamlpage (+ 24 341) "18. Concurrent Programming with Async.")
;; (find-realworldocamlpage (+ 24 342) "Async Basics")
;; (find-realworldocamlpage (+ 24 345) "Ivars and Upon")
;; (find-realworldocamlpage (+ 24 347) "Examples: An Echo Server")
;; (find-realworldocamlpage (+ 24 350) "Improving the Echo Server")
;; (find-realworldocamlpage (+ 24 352) "Pipe.transfer")
;; (find-realworldocamltext (+ 24 352) "Pipe.transfer")
;; (find-realworldocamlpage (+ 24 353) "Example: Searching Definitions with DuckDuckGo")
;; (find-realworldocamlpage (+ 24 353) "URI Handling")
;; (find-realworldocamlpage (+ 24 354) "Parsing JSON Strings")
;; (find-realworldocamlpage (+ 24 354) "Executing an HTTP Client Query")
;; (find-realworldocamlpage (+ 24 357) "Exception Handling")
;; (find-realworldocamlpage (+ 24 358) "Monitors")
;; (find-realworldocamlpage (+ 24 361) "Example: Handling Exceptions with DuckDuckGo")
;; (find-realworldocamlpage (+ 24 363) "Timeouts, Cancellation, and Choices")
;; (find-realworldocamlpage (+ 24 366) "Working with System Threads")
;; (find-realworldocamlpage (+ 24 369) "Thread-Safety and Locking")
;; (find-realworldocamlpage (+ 24 471) "Index")
;; (find-realworldocamltext "")
;; Real World OCaml: Version 2, PDF edition (WIP)
;; http://dev.realworldocaml.org/
;; http://dev.realworldocaml.org/toc.html
;; http://dev.realworldocaml.org/book.pdf
;; http://dev.realworldocaml.org/install.html
(code-pdf-page "realworldocaml" "$S/http/dev.realworldocaml.org/book.pdf")
(code-pdf-text "realworldocaml" "$S/http/dev.realworldocaml.org/book.pdf")
;; (find-realworldocamlpage)
;; (find-realworldocamltext)
;; «penrose» (to ".penrose")
;; (find-books "__comp/__comp.el" "penrose")
;; http://penrose.ink/media/Penrose_SIGGRAPH2020.pdf
;; (find-es "penrose" "penrose-git")
(code-pdf-page "penrosesigg2020" "$S/http/penrose.ink/media/Penrose_SIGGRAPH2020.pdf")
(code-pdf-text "penrosesigg2020" "$S/http/penrose.ink/media/Penrose_SIGGRAPH2020.pdf")
;; (find-penrosesigg2020page)
;; (find-penrosesigg2020text)
;; (find-penrosesigg2020page 12 "into pieces or stages")
;; (find-penrosesigg2020text 12 "into pieces or stages")
;; (find-penrosesigg2020page 16 "REFERENCES")
;; (find-penrosesigg2020text 16 "REFERENCES")
;; «python» (to ".python")
;; (find-books "__comp/__comp.el" "python")
;; (find-angg ".emacs.papers" "python")
;; (find-es "python" "books")
;; «python-downey» (to ".python-downey")
;; (find-books "__comp/__comp.el" "python-downey")
(code-pdf-page "downeytp" "~/books/__comp/downey__think_python_2nd_ed.pdf")
(code-pdf-text "downeytp" "~/books/__comp/downey__think_python_2nd_ed.pdf" 22)
;; (find-downeytppage)
;; (find-downeytppage 1 "Contents")
;; (find-downeytptext "")
;; (find-downeytppage (+ 22 1) "1. The Way of the Program.")
;; (find-downeytppage (+ 22 1) "What Is a Program?")
;; (find-downeytppage (+ 22 2) "Running Python")
;; (find-downeytppage (+ 22 3) "The First Program")
;; (find-downeytppage (+ 22 3) "Arithmetic Operators")
;; (find-downeytppage (+ 22 4) "Values and Types")
;; (find-downeytppage (+ 22 5) "Formal and Natural Languages")
;; (find-downeytppage (+ 22 7) "Debugging")
;; (find-downeytppage (+ 22 8) "Glossary")
;; (find-downeytppage (+ 22 9) "Exercises")
;; (find-downeytppage (+ 22 11) "2. Variables, Expressions and Statements.")
;; (find-downeytppage (+ 22 11) "Assignment Statements")
;; (find-downeytppage (+ 22 12) "Variable Names")
;; (find-downeytppage (+ 22 12) "Expressions and Statements")
;; (find-downeytppage (+ 22 13) "Script Mode")
;; (find-downeytppage (+ 22 14) "Order of Operations")
;; (find-downeytppage (+ 22 15) "String Operations")
;; (find-downeytppage (+ 22 15) "Comments")
;; (find-downeytppage (+ 22 16) "Debugging")
;; (find-downeytppage (+ 22 17) "Glossary")
;; (find-downeytppage (+ 22 18) "Exercises")
;; (find-downeytppage (+ 22 21) "3. Functions.")
;; (find-downeytppage (+ 22 21) "Function Calls")
;; (find-downeytppage (+ 22 22) "Math Functions")
;; (find-downeytppage (+ 22 23) "Composition")
;; (find-downeytppage (+ 22 23) "Adding New Functions")
;; (find-downeytppage (+ 22 25) "Definitions and Uses")
;; (find-downeytppage (+ 22 25) "Flow of Execution")
;; (find-downeytppage (+ 22 26) "Parameters and Arguments")
;; (find-downeytppage (+ 22 27) "Variables and Parameters Are Local")
;; (find-downeytppage (+ 22 28) "Stack Diagrams")
;; (find-downeytppage (+ 22 29) "Fruitful Functions and Void Functions")
;; (find-downeytppage (+ 22 30) "Why Functions?")
;; (find-downeytppage (+ 22 30) "Debugging")
;; (find-downeytppage (+ 22 31) "Glossary")
;; (find-downeytppage (+ 22 32) "Exercises")
;; (find-downeytppage (+ 22 35) "4. Case Study: Interface Design.")
;; (find-downeytppage (+ 22 35) "The turtle Module")
;; (find-downeytppage (+ 22 37) "Simple Repetition")
;; (find-downeytppage (+ 22 38) "Exercises")
;; (find-downeytppage (+ 22 38) "Encapsulation")
;; (find-downeytppage (+ 22 39) "Generalization")
;; (find-downeytppage (+ 22 40) "Interface Design")
;; (find-downeytppage (+ 22 41) "Refactoring")
;; (find-downeytppage (+ 22 42) "A Development Plan")
;; (find-downeytppage (+ 22 43) "docstring")
;; (find-downeytppage (+ 22 43) "Debugging")
;; (find-downeytppage (+ 22 44) "Glossary")
;; (find-downeytppage (+ 22 44) "Exercises")
;; (find-downeytppage (+ 22 47) "5. Conditionals and Recursion.")
;; (find-downeytppage (+ 22 47) "Floor Division and Modulus")
;; (find-downeytppage (+ 22 48) "Boolean Expressions")
;; (find-downeytppage (+ 22 49) "Logical Operators")
;; (find-downeytppage (+ 22 49) "Conditional Execution")
;; (find-downeytppage (+ 22 49) "Alternative Execution")
;; (find-downeytppage (+ 22 50) "Chained Conditionals")
;; (find-downeytppage (+ 22 50) "Nested Conditionals")
;; (find-downeytppage (+ 22 51) "Recursion")
;; (find-downeytppage (+ 22 53) "Stack Diagrams for Recursive Functions")
;; (find-downeytppage (+ 22 53) "Infinite Recursion")
;; (find-downeytppage (+ 22 54) "Keyboard Input")
;; (find-downeytppage (+ 22 55) "Debugging")
;; (find-downeytppage (+ 22 56) "Glossary")
;; (find-downeytppage (+ 22 57) "Exercises")
;; (find-downeytppage (+ 22 61) "6. Fruitful Functions.")
;; (find-downeytppage (+ 22 61) "Return Values")
;; (find-downeytppage (+ 22 62) "Incremental Development")
;; (find-downeytppage (+ 22 64) "Composition")
;; (find-downeytppage (+ 22 65) "Boolean Functions")
;; (find-downeytppage (+ 22 66) "More Recursion")
;; (find-downeytppage (+ 22 68) "Leap of Faith")
;; (find-downeytppage (+ 22 68) "One More Example")
;; (find-downeytppage (+ 22 69) "Checking Types")
;; (find-downeytppage (+ 22 70) "Debugging")
;; (find-downeytppage (+ 22 71) "Glossary")
;; (find-downeytppage (+ 22 72) "Exercises")
;; (find-downeytppage (+ 22 75) "7. Iteration.")
;; (find-downeytppage (+ 22 75) "Reassignment")
;; (find-downeytppage (+ 22 75) "equality is a symmetric relationship")
;; (find-downeytptext (+ 22 75) "equality is a symmetric relationship")
;; (find-downeytppage (+ 22 76) "Updating Variables")
;; (find-downeytppage (+ 22 77) "The while Statement")
;; (find-downeytppage (+ 22 78) "break")
;; (find-downeytppage (+ 22 79) "Square Roots")
;; (find-downeytppage (+ 22 81) "Algorithms")
;; (find-downeytppage (+ 22 81) "Debugging")
;; (find-downeytppage (+ 22 82) "Glossary")
;; (find-downeytppage (+ 22 82) "Exercises")
;; (find-downeytppage (+ 22 85) "8. Strings.")
;; (find-downeytppage (+ 22 85) "A String Is a Sequence")
;; (find-downeytppage (+ 22 86) "len")
;; (find-downeytppage (+ 22 86) "Traversal with a for Loop")
;; (find-downeytppage (+ 22 87) "String Slices")
;; (find-downeytppage (+ 22 88) "Strings Are Immutable")
;; (find-downeytppage (+ 22 89) "Searching")
;; (find-downeytppage (+ 22 89) "Looping and Counting")
;; (find-downeytppage (+ 22 90) "String Methods")
;; (find-downeytppage (+ 22 91) "The in Operator")
;; (find-downeytppage (+ 22 92) "String Comparison")
;; (find-downeytppage (+ 22 92) "Debugging")
;; (find-downeytppage (+ 22 94) "Glossary")
;; (find-downeytppage (+ 22 95) "Exercises")
;; (find-downeytppage (+ 22 99) "9. Case Study: Word Play.")
;; (find-downeytppage (+ 22 99) "Reading Word Lists")
;; (find-downeytppage (+ 22 100) "Exercises")
;; (find-downeytppage (+ 22 101) "Search")
;; (find-downeytppage (+ 22 103) "Looping with Indices")
;; (find-downeytppage (+ 22 104) "Debugging")
;; (find-downeytppage (+ 22 105) "Glossary")
;; (find-downeytppage (+ 22 105) "Exercises")
;; (find-downeytppage (+ 22 107) "10. Lists.")
;; (find-downeytppage (+ 22 107) "A List Is a Sequence")
;; (find-downeytppage (+ 22 108) "Lists Are Mutable")
;; (find-downeytppage (+ 22 109) "Traversing a List")
;; (find-downeytppage (+ 22 110) "List Operations")
;; (find-downeytppage (+ 22 110) "List Slices")
;; (find-downeytppage (+ 22 111) "List Methods")
;; (find-downeytppage (+ 22 111) "Map, Filter and Reduce")
;; (find-downeytppage (+ 22 113) "Deleting Elements")
;; (find-downeytppage (+ 22 113) "Lists and Strings")
;; (find-downeytppage (+ 22 114) "Objects and Values")
;; (find-downeytppage (+ 22 115) "Aliasing")
;; (find-downeytppage (+ 22 116) "List Arguments")
;; (find-downeytppage (+ 22 118) "Debugging")
;; (find-downeytppage (+ 22 119) "Glossary")
;; (find-downeytppage (+ 22 120) "Exercises")
;; (find-downeytppage (+ 22 125) "11. Dictionaries.")
;; (find-downeytppage (+ 22 125) "A Dictionary Is a Mapping")
;; (find-downeytppage (+ 22 127) "Dictionary as a Collection of Counters")
;; (find-downeytppage (+ 22 128) "Looping and Dictionaries")
;; (find-downeytppage (+ 22 129) "Reverse Lookup")
;; (find-downeytppage (+ 22 130) "Dictionaries and Lists")
;; (find-downeytppage (+ 22 131) "Memos")
;; (find-downeytppage (+ 22 133) "Global Variables")
;; (find-downeytppage (+ 22 134) "Debugging")
;; (find-downeytppage (+ 22 135) "Glossary")
;; (find-downeytppage (+ 22 137) "Exercises")
;; (find-downeytppage (+ 22 139) "12. Tuples.")
;; (find-downeytppage (+ 22 139) "Tuples Are Immutable")
;; (find-downeytppage (+ 22 141) "Tuple Assignment")
;; (find-downeytppage (+ 22 141) "Tuples as Return Values")
;; (find-downeytppage (+ 22 142) "Variable-Length Argument Tuples")
;; (find-downeytppage (+ 22 143) "Lists and Tuples")
;; (find-downeytppage (+ 22 144) "Dictionaries and Tuples")
;; (find-downeytppage (+ 22 146) "Sequences of Sequences")
;; (find-downeytppage (+ 22 147) "Debugging")
;; (find-downeytppage (+ 22 148) "Glossary")
;; (find-downeytppage (+ 22 148) "Exercises")
;; (find-downeytppage (+ 22 151) "13. Case Study: Data Structure Selection.")
;; (find-downeytppage (+ 22 151) "Word Frequency Analysis")
;; (find-downeytppage (+ 22 152) "Random Numbers")
;; (find-downeytppage (+ 22 153) "Word Histogram")
;; (find-downeytppage (+ 22 155) "Most Common Words")
;; (find-downeytppage (+ 22 155) "Optional Parameters")
;; (find-downeytppage (+ 22 156) "Dictionary Subtraction")
;; (find-downeytppage (+ 22 157) "Random Words")
;; (find-downeytppage (+ 22 158) "Markov Analysis")
;; (find-downeytppage (+ 22 159) "Data Structures")
;; (find-downeytppage (+ 22 161) "Debugging")
;; (find-downeytppage (+ 22 162) "Glossary")
;; (find-downeytppage (+ 22 163) "Exercises")
;; (find-downeytppage (+ 22 165) "14. Files.")
;; (find-downeytppage (+ 22 165) "Persistence")
;; (find-downeytppage (+ 22 166) "Reading and Writing")
;; (find-downeytppage (+ 22 166) "Format Operator")
;; (find-downeytppage (+ 22 167) "Filenames and Paths")
;; (find-downeytppage (+ 22 169) "Catching Exceptions")
;; (find-downeytppage (+ 22 169) "Databases")
;; (find-downeytppage (+ 22 170) "Pickling")
;; (find-downeytppage (+ 22 171) "Pipes")
;; (find-downeytppage (+ 22 172) "Writing Modules")
;; (find-downeytppage (+ 22 173) "Debugging")
;; (find-downeytppage (+ 22 174) "Glossary")
;; (find-downeytppage (+ 22 175) "Exercises")
;; (find-downeytppage (+ 22 177) "15. Classes and Objects.")
;; (find-downeytppage (+ 22 177) "Programmer-Defined Types")
;; (find-downeytppage (+ 22 178) "Attributes")
;; (find-downeytppage (+ 22 179) "Rectangles")
;; (find-downeytppage (+ 22 181) "Instances as Return Values")
;; (find-downeytppage (+ 22 181) "Objects Are Mutable")
;; (find-downeytppage (+ 22 182) "Copying")
;; (find-downeytppage (+ 22 183) "Debugging")
;; (find-downeytppage (+ 22 184) "Glossary")
;; (find-downeytppage (+ 22 185) "Exercises")
;; (find-downeytppage (+ 22 187) "16. Classes and Functions.")
;; (find-downeytppage (+ 22 187) "Time")
;; (find-downeytppage (+ 22 188) "Pure Functions")
;; (find-downeytppage (+ 22 189) "Modifiers")
;; (find-downeytppage (+ 22 190) "Prototyping versus Planning")
;; (find-downeytppage (+ 22 192) "Debugging")
;; (find-downeytppage (+ 22 192) "Glossary")
;; (find-downeytppage (+ 22 193) "Exercises")
;; (find-downeytppage (+ 22 195) "17. Classes and Methods.")
;; (find-downeytppage (+ 22 195) "Object-Oriented Features")
;; (find-downeytppage (+ 22 196) "Printing Objects")
;; (find-downeytppage (+ 22 198) "Another Example")
;; (find-downeytppage (+ 22 198) "A More Complicated Example")
;; (find-downeytppage (+ 22 199) "The init Method")
;; (find-downeytppage (+ 22 200) "The __str__ Method")
;; (find-downeytppage (+ 22 200) "Operator Overloading")
;; (find-downeytppage (+ 22 201) "Type-Based Dispatch")
;; (find-downeytppage (+ 22 202) "Polymorphism")
;; (find-downeytppage (+ 22 203) "Interface and Implementation")
;; (find-downeytppage (+ 22 204) "Debugging")
;; (find-downeytppage (+ 22 204) "Glossary")
;; (find-downeytppage (+ 22 205) "Exercises")
;; (find-downeytppage (+ 22 207) "18. Inheritance.")
;; (find-downeytppage (+ 22 207) "Card Objects")
;; (find-downeytppage (+ 22 208) "Class Attributes")
;; (find-downeytppage (+ 22 210) "Comparing Cards")
;; (find-downeytppage (+ 22 211) "Decks")
;; (find-downeytppage (+ 22 211) "Printing the Deck")
;; (find-downeytppage (+ 22 212) "Add, Remove, Shuffle and Sort")
;; (find-downeytppage (+ 22 213) "Inheritance")
;; (find-downeytppage (+ 22 214) "Class Diagrams")
;; (find-downeytppage (+ 22 215) "Data Encapsulation")
;; (find-downeytppage (+ 22 217) "Debugging")
;; (find-downeytppage (+ 22 218) "Glossary")
;; (find-downeytppage (+ 22 219) "Exercises")
;; (find-downeytppage (+ 22 223) "19. The Goodies.")
;; (find-downeytppage (+ 22 223) "Conditional Expressions")
;; (find-downeytppage (+ 22 224) "List Comprehensions")
;; (find-downeytppage (+ 22 225) "Generator Expressions")
;; (find-downeytppage (+ 22 226) "any and all")
;; (find-downeytppage (+ 22 226) "Sets")
;; (find-downeytppage (+ 22 228) "Counters")
;; (find-downeytppage (+ 22 229) "defaultdict")
;; (find-downeytppage (+ 22 230) "Named Tuples")
;; (find-downeytppage (+ 22 232) "Gathering Keyword Args")
;; (find-downeytppage (+ 22 233) "Glossary")
;; (find-downeytppage (+ 22 233) "Exercises")
;; (find-downeytppage (+ 22 235) "20. Debugging.")
;; (find-downeytppage (+ 22 235) "Syntax Errors")
;; (find-downeytppage (+ 22 237) "I keep making changes and it makes no difference.")
;; (find-downeytppage (+ 22 237) "Runtime Errors")
;; (find-downeytppage (+ 22 237) "My program does absolutely nothing.")
;; (find-downeytppage (+ 22 238) "My program hangs.")
;; (find-downeytppage (+ 22 239) "When I run the program I get an exception.")
;; (find-downeytppage (+ 22 240) "I added so many print statements I get inundated with output.")
;; (find-downeytppage (+ 22 241) "Semantic Errors")
;; (find-downeytppage (+ 22 241) "My program doesn't work.")
;; (find-downeytppage (+ 22 242) "I've got a big hairy expression and it doesn't do what I expect.")
;; (find-downeytppage (+ 22 243) "I've got a function that doesn't return what I expect.")
;; (find-downeytppage (+ 22 243) "I'm really, really stuck and I need help.")
;; (find-downeytppage (+ 22 243) "No, I really need help.")
;; (find-downeytppage (+ 22 245) "21. Analysis of Algorithms.")
;; (find-downeytppage (+ 22 246) "Order of Growth")
;; (find-downeytppage (+ 22 248) "Analysis of Basic Python Operations")
;; (find-downeytppage (+ 22 250) "Analysis of Search Algorithms")
;; (find-downeytppage (+ 22 251) "Hashtables")
;; (find-downeytppage (+ 22 255) "Glossary")
;; (find-downeytppage (+ 22 257) "Index.")
(code-xpdf "corepython" "~/books/__comp/chun__core_python_programmingr_2nd_ed.pdf")
(code-pdftotext "corepython" "~/books/__comp/chun__core_python_programmingr_2nd_ed.pdf" 0)
;; (ee-page-parameters "corepython" 0)
;; (find-corepythonpage 1 "Contents")
;; (find-corepythonpage 57 "Chapter 2. Getting Started")
;; (find-corepythontext 57 "Chapter 2. Getting Started")
;; (find-corepythonpage (+ 1 1) "Index")
;; (find-corepythontext "")
(code-xpdf "pypocketref" "~/books/__comp/lutz__python_pocket_reference_4th_ed.pdf")
(code-pdftotext "pypocketref" "~/books/__comp/lutz__python_pocket_reference_4th_ed.pdf" 12)
;; (ee-page-parameters "pypocketref" 12)
;; (find-pypocketrefpage 7 "Contents")
;; (find-pypocketrefpage (+ 12 189) "Index")
;; (find-pypocketreftext "")
(code-xpdf "pycookbook" "~/books/__comp/martelli_ascher__python_cookbook.pdf")
(code-pdftotext "pycookbook" "~/books/__comp/martelli_ascher__python_cookbook.pdf")
;; (find-pycookbookpage 2 "Contents")
;; (find-pycookbookpage 33 "1")
;; (find-pycookbookpage (+ 1 1) "Index")
;; (find-pycookbooktext "")
;; «R» (to ".R")
;; (find-es "r")
;; (find-fline "~/books/__comp/")
(code-xpdf "teetor" "~/books/__comp/teetor__25_recipes_for_getting_started_with_R.pdf")
(code-pdf-text "teetor" "~/books/__comp/teetor__25_recipes_for_getting_started_with_R.pdf")
;; (find-teetorpage)
;; (find-teetortext)
;; «ruby» (to ".ruby")
;; «rubyforrails» (to ".rubyforrails")
;; (find-books "__comp/__comp.el" "rubyforrails")
(code-pdf-page "rubyforrails" "~/books/__comp/black__ruby_for_rails.pdf")
(code-pdf-text "rubyforrails" "~/books/__comp/black__ruby_for_rails.pdf" 35)
;; (find-rubyforrailspage)
;; (find-rubyforrailspage 8 "Brief Contents")
;; (find-rubyforrailspage 10 "Contents")
;; (find-rubyforrailspage (+ 35 477) "Index")
;; (find-rubyforrailstext "")
;; (find-unpack-chm-links "~/books/__comp/fulton__the_ruby_way.chm" "/tmp/rubyway/" "rubyway")
(code-c-d "rubyway" "/tmp/rubyway/0768667208/")
;; (find-rubywayfile "")
;; (find-rubywayw3m "toc.html")
;; (find-rubywayw3m "index.html")
;; «rubynutshell» (to ".rubynutshell")
;; (find-books "__comp/__comp.el" "rubynutshell")
(code-pdf-page "rubynutshell" "~/books/__comp/matz__ruby_in_a_nutshell.pdf")
(code-pdf-text "rubynutshell" "~/books/__comp/matz__ruby_in_a_nutshell.pdf")
;; (find-rubynutshellpage 2 "Contents")
;; (find-rubynutshellpage 10 "1. Introduction")
;; (find-rubynutshellpage 11 "1.1. Ruby's Elegance")
;; (find-rubynutshellpage 14 "1.2. Ruby in Action")
;; (find-rubynutshellpage 16 "2. Language Basics")
;; (find-rubynutshellpage 17 "2.1. Command-Line Options")
;; (find-rubynutshellpage 20 "2.2. Environment Variables")
;; (find-rubynutshellpage 22 "2.3. Lexical Conventions")
;; (find-rubynutshellpage 24 "2.4. Literals")
;; (find-rubynutshellpage 31 "2.5. Variables")
;; (find-rubynutshellpage 34 "2.6. Operators")
;; (find-rubynutshellpage 37 "2.7. Methods")
;; (find-rubynutshellpage 41 "2.8. Control Structures")
;; (find-rubynutshellpage 45 "2.9. Object-Oriented Programming")
;; (find-rubynutshellpage 49 "2.10. Security")
;; (find-rubynutshellpage 53 "3. Built-in Library Reference")
;; (find-rubynutshellpage 54 "3.1. Predefined Variables")
;; (find-rubynutshellpage 57 "3.2. Predefined Global Constants")
;; (find-rubynutshellpage 59 "3.3. Built-in Functions")
;; (find-rubynutshellpage 68 "3.4. Built-in Library")
;; (find-rubynutshellpage 136 "4. Standard Library Reference")
;; (find-rubynutshellpage 137 "4.1. Standard Library")
;; (find-rubynutshellpage 184 "5. Ruby Tools")
;; (find-rubynutshellpage 185 "5.1. Standard Tools")
;; (find-rubynutshellpage 192 "5.2. Additional Tools")
;; (find-rubynutshellpage 194 "5.3. Ruby Application Archive")
;; (find-rubynutshellpage 195 "6. Ruby Updates")
;; (find-rubynutshellpage 196 "6.1. Summary of Changes")
;; (find-rubynutshellpage 197 "6.2. Changes from 1.6.5 to 1.7.1")
;; (find-rubynutshellpage 199 "6.3. The Future of Ruby")
;; (find-rubynutshellpage 200 "6.4. Participate in Ruby")
;; (find-rubynutshelltext "")
;; «pragmaticruby» (to ".pragmaticruby")
;; (find-books "__comp/__comp.el" "pragmaticruby")
(code-pdf-page "pragmaticruby" "~/books/__comp/thomas__programming_ruby_the_pragmatic_programmers_guide.pdf")
(code-pdf-text "pragmaticruby" "~/books/__comp/thomas__programming_ruby_the_pragmatic_programmers_guide.pdf" 28)
;; (find-pragmaticrubypage)
;; (find-pragmaticrubypage 6 "Contents")
;; (find-pragmaticrubytext 6 "Contents")
;; (find-pragmaticrubypage (+ 28 762) "Index")
;; (find-pragmaticrubypage (+ 28 797) "Template characters")
;; (find-pragmaticrubytext "")
;; «scala» (to ".scala")
(code-xpdf "progscala" "~/books/__comp/odersky_spoon_venners__programming_in_scala_2nd_ed.pdf")
(code-pdftotext "progscala" "~/books/__comp/odersky_spoon_venners__programming_in_scala_2nd_ed.pdf")
;; (find-progscalapage 10 "Contents")
;; (find-progscalapage 11 "Contents")
;; (find-progscalapage (+ 0 846) "Index")
;; (find-progscalatext "")
;; «scheme» (to ".scheme")
;; «little-schemer» (to ".little-schemer")
;; (find-books "__comp/__comp.el" "little-schemer")
(code-pdf-page "littleschemer" "~/books/__comp/friedman_felleisen__the_little_schemer_4th_ed.pdf")
(code-pdf-text "littleschemer" "~/books/__comp/friedman_felleisen__the_little_schemer_4th_ed.pdf" 1)
;; (find-littleschemerpage)
;; (find-littleschemerpage 1 "Contents")
;; (find-littleschemerpage (+ 1 189) "Index")
;; (find-littleschemertext "")
;; «shell» (to ".shell")
(code-xpdf "classicshell" "~/books/__comp/robbins_beebe__classic_shell_scripting.pdf")
(code-pdf-text "classicshell" "~/books/__comp/robbins_beebe__classic_shell_scripting.pdf" 24)
;; (find-classicshellpage (+ 24 1))
;; (find-classicshelltext (+ 24 1))
;; «smalltalk» (to ".smalltalk")
;; SmallTalk books:
;; http://wiki.squeak.org/squeak/64
;; http://stephane.ducasse.free.fr/FreeBooks/BlueBook/
;; http://wiki.squeak.org/squeak/65
;; http://wiki.squeak.org/squeak/66
;; http://wiki.squeak.org/squeak/576
;; http://wiki.squeak.org/squeak/1600
;; http://wiki.squeak.org/squeak/920
;;
;; http://library.nu/search?q=smalltalk
;; http://wiki.squeak.org/squeak/1859
;; http://web.cecs.pdx.edu/~black/OOP/Tutorial/SqueakLanguageRef.html
;; http://web.cecs.pdx.edu/~black/OOP/Tutorial/Squeak%20Classes%20Ref.html
(code-xpdf "goldbergbluebook" "~/books/__comp/goldberg_robson__smalltalk-80_the_language_and_its_implementation.pdf")
(code-pdftotext "goldbergbluebook" "~/books/__comp/goldberg_robson__smalltalk-80_the_language_and_its_implementation.pdf" 22)
;; (ee-page-parameters "goldbergbluebook" 22)
;; (find-goldbergbluebookpage 17 "Contents")
;; (find-goldbergbluebookpage (+ 22 32) "An Example" "Application")
;; (find-goldbergbluebookpage (+ 22 691) "Subject Index")
;; (find-goldbergbluebookpage (+ 22 699) "System Index")
;; (find-goldbergbluebookpage (+ 22 703) "Example Class Index")
;; (find-goldbergbluebookpage (+ 22 707) "Implementation Index")
;; (find-goldbergbluebooktext "")
;; PART ONE
;; (find-goldbergbluebookpage (+ 22 5) "1. Objects and Messages")
;; (find-goldbergbluebookpage (+ 22 8) "Classes and Instances")
;; (find-goldbergbluebookpage (+ 22 10) "An Example Application")
;; (find-goldbergbluebookpage (+ 22 13) "System Classes")
;; (find-goldbergbluebookpage (+ 22 16) "Summary of Terminology")
;;
;; (find-goldbergbluebookpage (+ 22 17) "2. Expression Syntax")
;; (find-goldbergbluebookpage (+ 22 19) "Literals")
;; (find-goldbergbluebookpage (+ 22 21) "Variables")
;; (find-goldbergbluebookpage (+ 22 24) "Messages")
;; (find-goldbergbluebookpage (+ 22 31) "Blocks")
;; (find-goldbergbluebookpage (+ 22 37) "Summary of Terminology")
;;
;; (find-goldbergbluebookpage (+ 22 39) "3. Classes and Instances")
;; (find-goldbergbluebookpage (+ 22 41) "Protocol Descriptions")
;; (find-goldbergbluebookpage (+ 22 43) "Implementation Descriptions")
;; (find-goldbergbluebookpage (+ 22 44) "Variable Declarations")
;; (find-goldbergbluebookpage (+ 22 46) "Methods")
;; (find-goldbergbluebookpage (+ 22 52) "Primitive Methods")
;; (find-goldbergbluebookpage (+ 22 53) "Summary of Terminology")
;;
;; (find-goldbergbluebookpage (+ 22 55) "4. Subclasses")
;; (find-goldbergbluebookpage (+ 22 58) "Subclass Descriptions")
;; (find-goldbergbluebookpage (+ 22 59) "An Example Subclass")
;; (find-goldbergbluebookpage (+ 22 61) "Method Determination")
;; (find-goldbergbluebookpage (+ 22 66) "Abstract Superclasses")
;; (find-goldbergbluebookpage (+ 22 72) "Subclass Framework Messages")
;; (find-goldbergbluebookpage (+ 22 73) "Summary of Terminology")
;;
;; (find-goldbergbluebookpage (+ 22 75) "5. Metaclasses")
;; (find-goldbergbluebookpage (+ 22 77) "Initialization of Instances")
;; (find-goldbergbluebookpage (+ 22 78) "An Example Metaclass")
;; (find-goldbergbluebookpage (+ 22 81) "Metaclass Inheritance")
;; (find-goldbergbluebookpage (+ 22 84) "Initialization of Class Variables")
;; (find-goldbergbluebookpage (+ 22 88) "Summary of Method Determination")
;; (find-goldbergbluebookpage (+ 22 89) "Summary of Terminology")
;;
;; PART TWO
;; (find-goldbergbluebookpage (+ 22 93) "6. Protocol for all Objects")
;; (find-goldbergbluebookpage (+ 22 95) "Testing the Functionality of an Object")
;; (find-goldbergbluebookpage (+ 22 96) "Comparing Objects")
;; (find-goldbergbluebookpage (+ 22 97) "Copying Objects")
;; (find-goldbergbluebookpage (+ 22 99) "Accessing the Parts of an Object")
;; (find-goldbergbluebookpage (+ 22 100) "Printing and Storing Objects")
;; (find-goldbergbluebookpage (+ 22 102) "Error Handling")
;;
;; (find-goldbergbluebookpage (+ 22 105) "7 Linear Measures")
;; (find-goldbergbluebookpage (+ 22 107) "Class Magnitude")
;; (find-goldbergbluebookpage (+ 22 108) "Class Date")
;; (find-goldbergbluebookpage (+ 22 111) "Class Time")
;; (find-goldbergbluebookpage (+ 22 114) "Class Character")
;;
;; (find-goldbergbluebookpage (+ 22 117) "8 Numerical Classes")
;; (find-goldbergbluebookpage (+ 22 120) "Protocol of the Number Classes")
;; (find-goldbergbluebookpage (+ 22 126) "Classes Float and Fraction")
;; (find-goldbergbluebookpage (+ 22 127) "Integer Classes")
;; (find-goldbergbluebookpage (+ 22 129) "Class Random: A Random Number Generator")
;;
;; (find-goldbergbluebookpage (+ 22 131) "9 Protocol for All Collection Classes")
;; (find-goldbergbluebookpage (+ 22 134) "Adding, Removing, and Testing Elements")
;; (find-goldbergbluebookpage (+ 22 136) "Enumerating Elements")
;; (find-goldbergbluebookpage (+ 22 139) "Instance Creation")
;; (find-goldbergbluebookpage (+ 22 140) "Conversion Among Collection Classes")
;;
;; (find-goldbergbluebookpage (+ 22 143) "10 Hierarchy of the Collection Classes")
;; (find-goldbergbluebookpage (+ 22 147) "Class Bag")
;; (find-goldbergbluebookpage (+ 22 148) "Class Set")
;; (find-goldbergbluebookpage (+ 22 148) "Classes Dictionary and IdentityDictionary")
;; (find-goldbergbluebookpage (+ 22 153) "Class SequenceableCollection")
;; (find-goldbergbluebookpage (+ 22 157) "Subclasses of SequenceableCollection")
;; (find-goldbergbluebookpage (+ 22 165) "Class ArrayedCollection")
;; (find-goldbergbluebookpage (+ 22 168) "Class MappedCollection")
;; (find-goldbergbluebookpage (+ 22 169) "Summary of Conversions Among Collections")
;;
;; (find-goldbergbluebookpage (+ 22 171) "11 Three Examples that Use Collections")
;; (find-goldbergbluebookpage (+ 22 172) "Random Selection and Playing Cards")
;; (find-goldbergbluebookpage (+ 22 181) "The Drunken Cockroach Problem")
;; (find-goldbergbluebookpage (+ 22 185) "Traversing Binary Trees")
;;
;; (find-goldbergbluebookpage (+ 22 193) "12 Protocol for Streams")
;; (find-goldbergbluebookpage (+ 22 195) "Class Stream")
;; (find-goldbergbluebookpage (+ 22 198) "Positionable Streams")
;; (find-goldbergbluebookpage (+ 22 204) "Streams of Generated Elements")
;; (find-goldbergbluebookpage (+ 22 205) "Streams for Collections Without External Keys")
;; (find-goldbergbluebookpage (+ 22 208) "External Streams and File Streams")
;;
;; (find-goldbergbluebookpage (+ 22 211) "13 Implementations of the Basic Collection Protocol")
;; (find-goldbergbluebookpage (+ 22 212) "Class Collection")
;; (find-goldbergbluebookpage (+ 22 219) "Subclasses of Collection")
;;
;; (find-goldbergbluebookpage (+ 22 235) "14 Kernel Support")
;; (find-goldbergbluebookpage (+ 22 237) "Class UndefinedObject")
;; (find-goldbergbluebookpage (+ 22 237) "Classes Boolean, True, and False")
;; (find-goldbergbluebookpage (+ 22 239) "Additional Protocol for Class Object")
;;
;; (find-goldbergbluebookpage (+ 22 249) "15 Multiple Independent Processes")
;; (find-goldbergbluebookpage (+ 22 251) "Processes")
;; (find-goldbergbluebookpage (+ 22 257) "Semaphores")
;; (find-goldbergbluebookpage (+ 22 265) "Class SharedQueue")
;; (find-goldbergbluebookpage (+ 22 266) "Class Delay")
;;
;; (find-goldbergbluebookpage (+ 22 267) "16 Protocol for Classes")
;; (find-goldbergbluebookpage (+ 22 272) "Class Behavior")
;; (find-goldbergbluebookpage (+ 22 284) "Class ClassDescription")
;; (find-goldbergbluebookpage (+ 22 287) "Class Metaclass")
;; (find-goldbergbluebookpage (+ 22 288) "Class Class")
;;
;; (find-goldbergbluebookpage (+ 22 291) "17 The Programming Interface")
;; (find-goldbergbluebookpage (+ 22 292) "Views")
;; (find-goldbergbluebookpage (+ 22 297) "Browsers")
;; (find-goldbergbluebookpage (+ 22 308) "Testing")
;; (find-goldbergbluebookpage (+ 22 314) "Error Reporting")
;;
;; (find-goldbergbluebookpage (+ 22 329) "18 Graphics Kernel")
;; (find-goldbergbluebookpage (+ 22 331) "Graphical Representation")
;; (find-goldbergbluebookpage (+ 22 331) "Graphical Storage")
;; (find-goldbergbluebookpage (+ 22 333) "Graphical Manipulation")
;; (find-goldbergbluebookpage (+ 22 338) "Classes Form and Bitmap")
;; (find-goldbergbluebookpage (+ 22 340) "Spatial Reference")
;; (find-goldbergbluebookpage (+ 22 349) "Class BitBIt")
;; (find-goldbergbluebookpage (+ 22 351) "Line Drawing")
;; (find-goldbergbluebookpage (+ 22 354) "Text Display")
;; (find-goldbergbluebookpage (+ 22 355) "Simulation of BitBIt")
;;
;; (find-goldbergbluebookpage (+ 22 364) "19 Pens")
;; (find-goldbergbluebookpage (+ 22 365) "Class Pen")
;; (find-goldbergbluebookpage (+ 22 370) "Geometric Designs")
;; (find-goldbergbluebookpage (+ 22 375) "Commander Pen")
;;
;; (find-goldbergbluebookpage (+ 22 381) "20 Display Objects")
;; (find-goldbergbluebookpage (+ 22 383) "Class DisplayObject")
;; (find-goldbergbluebookpage (+ 22 390) "Class DisplayMedium")
;; (find-goldbergbluebookpage (+ 22 396) "Forms")
;; (find-goldbergbluebookpage (+ 22 400) "Display Text")
;; (find-goldbergbluebookpage (+ 22 400) "Paths")
;; (find-goldbergbluebookpage (+ 22 405) "Image Manipulation with Forms")
;;
;; PART THREE
;; (find-goldbergbluebookpage (+ 22 417) "21 Probability Distributions")
;; (find-goldbergbluebookpage (+ 22 418) "Probability Distribution Framework")
;; (find-goldbergbluebookpage (+ 22 423) "Discrete Probability Distributions")
;; (find-goldbergbluebookpage (+ 22 432) "Continuous Probability Distributions")
;;
;; (find-goldbergbluebookpage (+ 22 439) "22 Event-Driven Simulations")
;; (find-goldbergbluebookpage (+ 22 442) "A Framework for Simulation")
;; (find-goldbergbluebookpage (+ 22 452) "Implementation of the Simulation Classes")
;;
;; (find-goldbergbluebookpage (+ 22 465) "23 Statistics Gathering in Event - Driven Simulations")
;; (find-goldbergbluebookpage (+ 22 466) "Duration Statistics")
;; (find-goldbergbluebookpage (+ 22 469) "Throughput Histograms")
;; (find-goldbergbluebookpage (+ 22 474) "Tallying Events")
;; (find-goldbergbluebookpage (+ 22 476) "Event Monitoring")
;;
;; (find-goldbergbluebookpage (+ 22 483) "24 The Use of Resources in Event - Driven Simulations")
;; (find-goldbergbluebookpage (+ 22 484) "Implementing ResourceProvider and StaticResource")
;; (find-goldbergbluebookpage (+ 22 489) "Consumable Resources")
;; (find-goldbergbluebookpage (+ 22 492) "Nonconsumable Resources")
;; (find-goldbergbluebookpage (+ 22 503) "Renewable Resources")
;;
;; (find-goldbergbluebookpage (+ 22 515) "25 Coordinated Resources for Event-Driven Simulations")
;; (find-goldbergbluebookpage (+ 22 516) "The Implementation of Class ResourceCoordinator")
;; (find-goldbergbluebookpage (+ 22 518) "Example: A Car Wash Simulation")
;; (find-goldbergbluebookpage (+ 22 521) "Example: A Ferry Service for a Special Truck")
;; (find-goldbergbluebookpage (+ 22 526) "Example: A Bank")
;; (find-goldbergbluebookpage (+ 22 533) "Example: An Information System")
;;
;; PART FOUR
;; (find-goldbergbluebookpage (+ 22 541) "26 The Implementation")
;; (find-goldbergbluebookpage (+ 22 542) "The Compiler")
;; (find-goldbergbluebookpage (+ 22 550) "The Interpreter")
;; (find-goldbergbluebookpage (+ 22 564) "The Object Memory")
;; (find-goldbergbluebookpage (+ 22 566) "The Hardware")
;;
;; (find-goldbergbluebookpage (+ 22 567) "27 Specification of the Virtual Machine")
;; (find-goldbergbluebookpage (+ 22 568) "Form of the Specification")
;; (find-goldbergbluebookpage (+ 22 570) "Object Memory Interface")
;; (find-goldbergbluebookpage (+ 22 575) "Objects Used by the Interpreter")
;;
;; (find-goldbergbluebookpage (+ 22 593) "28 Formal Specification of the Interpreter")
;; (find-goldbergbluebookpage (+ 22 597) "Stack Bytecodes")
;; (find-goldbergbluebookpage (+ 22 601) "Jump Bytecodes")
;; (find-goldbergbluebookpage (+ 22 603) "Send Bytecodes")
;; (find-goldbergbluebookpage (+ 22 608) "Return Bytecodes")
;;
;; (find-goldbergbluebookpage (+ 22 611) "29 Formal Specification of the Primitive Methods")
;; (find-goldbergbluebookpage (+ 22 621) "Arithmetic Primitives")
;; (find-goldbergbluebookpage (+ 22 627) "Array and Stream Primitives")
;; (find-goldbergbluebookpage (+ 22 633) "Storage Management Primitives")
;; (find-goldbergbluebookpage (+ 22 637) "Control Primitives")
;; (find-goldbergbluebookpage (+ 22 647) "Input/Output Primitives")
;; (find-goldbergbluebookpage (+ 22 652) "System Primitives")
;;
;; (find-goldbergbluebookpage (+ 22 655) "30 Formal Specification of the Object Memory")
;; (find-goldbergbluebookpage (+ 22 657) "Heap Storage")
;; (find-goldbergbluebookpage (+ 22 659) "The Object Table")
;; (find-goldbergbluebookpage (+ 22 667) "Allocation and Deallocation")
;; (find-goldbergbluebookpage (+ 22 674) "Garbage Collection")
;; (find-goldbergbluebookpage (+ 22 684) "Nonpointer Objects")
;; (find-goldbergbluebookpage (+ 22 686) "Interface to the Bytecode Interpreter")
;;
;; (find-goldbergbluebookpage (+ 22 691) "Subject Index")
;; (find-goldbergbluebookpage (+ 22 699) "System Index")
;; (find-goldbergbluebookpage (+ 22 703) "Example Class Index")
;; (find-goldbergbluebookpage (+ 22 707) "Implementation Index")
(code-xpdf "goldbergredbook" "~/books/__comp/goldberg__smalltalk-80_the_interactive_programming_environment.pdf")
(code-pdftotext "goldbergredbook" "~/books/__comp/goldberg__smalltalk-80_the_interactive_programming_environment.pdf")
;; (find-goldbergredbookpage 7 "Contents")
;; (find-goldbergredbookpage (+ 9 503) "System Workspace Index")
;; (find-goldbergredbookpage (+ 9 510) "Menu Command Index")
;; (find-goldbergredbookpage (+ 9 512) "Subject Index")
;; (find-goldbergredbooktext "")
(code-xpdf "insidesmalltalk1" "~/books/__comp/lalonde_pugh__inside_smalltalk_vol_1.pdf")
(code-pdftotext "insidesmalltalk1" "~/books/__comp/lalonde_pugh__inside_smalltalk_vol_1.pdf")
;; (find-insidesmalltalk1page 3 "Contents")
;; (find-insidesmalltalk1page (+ 16 506) "Class Index")
;; (find-insidesmalltalk1page (+ 16 508) "Index")
;; (find-insidesmalltalk1text "")
(code-xpdf "insidesmalltalk2" "~/books/__comp/lalonde_pugh__inside_smalltalk_vol_2.pdf")
(code-pdftotext "insidesmalltalk2" "~/books/__comp/lalonde_pugh__inside_smalltalk_vol_2.pdf")
;; (find-insidesmalltalk2page 5 "Contents")
;; (find-insidesmalltalk2page (+ 20 545) "Class Index")
;; (find-insidesmalltalk2page (+ 20 549) "Index")
;; (find-insidesmalltalk2text "")
(code-xpdf "smalltalkbyex" "~/books/__comp/sharp__smalltalk_by_example.pdf")
(code-pdftotext "smalltalkbyex" "~/books/__comp/sharp__smalltalk_by_example.pdf")
;; (find-smalltalkbyexpage (+ 1 9) "1. Basic Concepts")
;; (find-smalltalkbyexpage (+ 1 16) "2. Messages")
;; (find-smalltalkbyextext "")
;; «squeak-by-example» (to ".squeak-by-example")
;; (find-es "squeak" "squeak-by-example")
;; (find-angg "SQUEAK/README")
;; https://github.com/hpi-swa-lab/SqueakByExample-english/releases/download/5.3.1/SBE-5.3.pdf
;; http://anggtwu.net/SQUEAK/squeak-by-example-5.3.pdf
;; (code-pdf-page "squeakbyex" "$S/https/github.com/hpi-swa-lab/SqueakByExample-english/releases/download/5.3.1/SBE-5.3.pdf")
;; (code-pdf-text8 "squeakbyex" "$S/https/github.com/hpi-swa-lab/SqueakByExample-english/releases/download/5.3.1/SBE-5.3.pdf" 16)
(code-pdf-page "squeakbyex" "$S/http/anggtwu.net/SQUEAK/squeak-by-example-5.3.pdf")
(code-pdf-text "squeakbyex" "$S/http/anggtwu.net/SQUEAK/squeak-by-example-5.3.pdf" 16)
;; (find-squeakbyexpage)
;; (find-squeakbyextext)
;; (find-squeakbyexpage 7 "Contents")
;; (find-squeakbyextext 7 "Contents")
;; (find-squeakbyexpage (+ 16 3) "1 A quick tour of Squeak")
;; (find-squeakbyexpage (+ 16 3) "1.1 Getting started")
;; (find-squeakbyexpage (+ 16 8) "1.2 The world menu")
;; (find-squeakbyexpage (+ 16 9) "1.3 Saving, quitting, and restarting a Squeak session")
;; (find-squeakbyexpage (+ 16 10) "1.4 Workspaces and transcripts")
;; (find-squeakbyexpage (+ 16 12) "1.5 Keyboard shortcuts")
;; (find-squeakbyexpage (+ 16 14) "1.6 The system browser")
;; (find-squeakbyexpage (+ 16 16) "1.7 Finding classes")
;; (find-squeakbyexpage (+ 16 17) "1.8 Finding methods")
;; (find-squeakbyexpage (+ 16 19) "1.9 Defining a new method")
;; (find-squeakbyexpage (+ 16 24) "1.10 Chapter summary.")
;; (find-squeakbyexpage (+ 16 27) "2 Your first interactive object: the Quinto game")
;; (find-squeakbyexpage (+ 16 27) "2.1 The Quinto game")
;; (find-squeakbyexpage (+ 16 28) "2.2 Creating a new class category")
;; (find-squeakbyexpage (+ 16 28) "2.3 Defining the class SBECell")
;; (find-squeakbyexpage (+ 16 31) "2.4 Adding methods to a class.")
;; (find-squeakbyexpage (+ 16 33) "2.5 Inspecting an object")
;; (find-squeakbyexpage (+ 16 34) "2.6 Defining the class SBEGame")
;; (find-squeakbyexpage (+ 16 37) "2.7 Organizing methods into protocols")
;; (find-squeakbyexpage (+ 16 41) "2.8 Let's try our code")
;; (find-squeakbyexpage (+ 16 43) "change the code" "while it is being debugged")
;; (find-squeakbyextext (+ 16 43) "change the code" "while it is being debugged")
;; (find-squeakbyexpage (+ 16 44) "2.9 Saving and sharing Smalltalk code.")
;; (find-squeakbyexpage (+ 16 47) "2.10 Chapter summary.")
;; (find-squeakbyexpage (+ 16 49) "3 Syntax in a nutshell")
;; (find-squeakbyexpage (+ 16 49) "3.1 Syntactic elements")
;; (find-squeakbyexpage (+ 16 53) "3.2 Pseudo-variables")
;; (find-squeakbyexpage (+ 16 53) "3.3 Message sends")
;; (find-squeakbyexpage (+ 16 55) "3.4 Method syntax")
;; (find-squeakbyexpage (+ 16 56) "3.5 Block syntax")
;; (find-squeakbyexpage (+ 16 57) "3.6 Conditionals and loops in a nutshell")
;; (find-squeakbyexpage (+ 16 59) "3.7 Primitives and pragmas")
;; (find-squeakbyexpage (+ 16 60) "3.8 Chapter summary.")
;; (find-squeakbyexpage (+ 16 61) "4 Understanding message syntax")
;; (find-squeakbyexpage (+ 16 61) "4.1 Identifying messages")
;; (find-squeakbyexpage (+ 16 63) "4.2 Three kinds of messages")
;; (find-squeakbyexpage (+ 16 65) "4.3 Message composition")
;; (find-squeakbyexpage (+ 16 71) "4.4 Hints for identifying keyword messages")
;; (find-squeakbyexpage (+ 16 73) "4.5 Expression sequences")
;; (find-squeakbyexpage (+ 16 73) "4.6 Cascaded messages")
;; (find-squeakbyexpage (+ 16 74) "4.7 Chapter summary.")
;; (find-squeakbyexpage (+ 16 77) "5 The Smalltalk object model")
;; (find-squeakbyexpage (+ 16 77) "5.1 The rules of the model")
;; (find-squeakbyexpage (+ 16 77) "5.2 Everything is an object")
;; (find-squeakbyexpage (+ 16 78) "5.3 Every object is an instance of a class")
;; (find-squeakbyexpage (+ 16 86) "5.4 Every class has a superclass")
;; (find-squeakbyexpage (+ 16 89) "5.5 Everything happens by sending messages")
;; (find-squeakbyexpage (+ 16 90) "5.6 Method lookup follows the inheritance chain")
;; (find-squeakbyexpage (+ 16 97) "5.7 Shared variables")
;; (find-squeakbyexpage (+ 16 102) "5.8 Chapter summary.")
;; (find-squeakbyexpage (+ 16 105) "6 The Squeak programming environment")
;; (find-squeakbyexpage (+ 16 106) "6.1 Overview")
;; (find-squeakbyexpage (+ 16 107) "6.2 The system browser")
;; (find-squeakbyexpage (+ 16 112) "Figure 6.6: A Class Browser")
;; (find-squeakbyextext (+ 16 112) "Figure 6.6: A Class Browser")
;; (find-squeakbyexpage (+ 16 115) "Method overridings")
;; (find-squeakbyextext (+ 16 115) "Method overridings")
;; (find-squeakbyexpage (+ 16 117) "prettyPrint ed source code")
;; (find-squeakbyextext (+ 16 117) "prettyPrint ed source code")
;; (find-squeakbyexpage (+ 16 120) "6.3 Monticello")
;; (find-squeakbyexpage (+ 16 127) "6.4 The inspector and the explorer")
;; (find-squeakbyexpage (+ 16 130) "6.5 The debugger")
;; (find-squeakbyextext (+ 16 130) "The debugger")
;; (find-squeakbyexpage (+ 16 138) "6.6 The process browser")
;; (find-squeakbyexpage (+ 16 139) "6.7 Finding methods")
;; (find-squeakbyexpage (+ 16 140) "6.8 Change sets and the change sorter")
;; (find-squeakbyexpage (+ 16 143) "6.9 The file list browser")
;; (find-squeakbyexpage (+ 16 145) "6.10 In Smalltalk, you can't lose code")
;; (find-squeakbyexpage (+ 16 146) "6.11 Other interesting tools")
;; (find-squeakbyexpage (+ 16 147) "6.12 Chapter summary.")
;; (find-squeakbyexpage (+ 16 149) "7 SUnit")
;; (find-squeakbyexpage (+ 16 149) "7.1 Introduction")
;; (find-squeakbyexpage (+ 16 150) "7.2 Why testing is important")
;; (find-squeakbyexpage (+ 16 151) "7.3 What makes a good test?")
;; (find-squeakbyexpage (+ 16 152) "7.4 SUnit by example")
;; (find-squeakbyexpage (+ 16 156) "7.5 The SUnit cook book")
;; (find-squeakbyexpage (+ 16 158) "7.6 The SUnit framework")
;; (find-squeakbyexpage (+ 16 160) "7.7 Advanced features of SUnit")
;; (find-squeakbyexpage (+ 16 162) "7.8 The implementation of SUnit.")
;; (find-squeakbyexpage (+ 16 165) "7.9 Some advice on testing")
;; (find-squeakbyexpage (+ 16 166) "7.10 Chapter summary.")
;; (find-squeakbyexpage (+ 16 169) "8 Basic Classes")
;; (find-squeakbyexpage (+ 16 169) "8.1 Object")
;; (find-squeakbyexpage (+ 16 179) "8.2 Numbers")
;; (find-squeakbyexpage (+ 16 183) "8.3 Characters")
;; (find-squeakbyexpage (+ 16 183) "8.4 Strings")
;; (find-squeakbyexpage (+ 16 185) "8.5 Booleans")
;; (find-squeakbyexpage (+ 16 187) "8.6 Exceptions")
;; (find-squeakbyexpage (+ 16 188) "8.7 Chapter summary.")
;; (find-squeakbyexpage (+ 16 191) "9 Collections")
;; (find-squeakbyexpage (+ 16 191) "9.1 Introduction")
;; (find-squeakbyexpage (+ 16 195) "9.2 Implementations of collections")
;; (find-squeakbyexpage (+ 16 196) "9.3 Examples of key classes.")
;; (find-squeakbyexpage (+ 16 207) "9.4 Collection iterators")
;; (find-squeakbyexpage (+ 16 211) "9.5 Some hints for using collections")
;; (find-squeakbyexpage (+ 16 212) "9.6 Sorting collections.")
;; (find-squeakbyexpage (+ 16 214) "9.7 Chapter summary.")
;; (find-squeakbyexpage (+ 16 217) "10 Streams")
;; (find-squeakbyexpage (+ 16 217) "10.1 Two sequences of elements")
;; (find-squeakbyexpage (+ 16 218) "10.2 Streams vs. collections")
;; (find-squeakbyexpage (+ 16 219) "10.3 Streaming over collections.")
;; (find-squeakbyexpage (+ 16 227) "10.4 Using streams for file access")
;; (find-squeakbyexpage (+ 16 230) "10.5 Chapter summary.")
;; (find-squeakbyexpage (+ 16 233) "11 Morphic")
;; (find-squeakbyexpage (+ 16 233) "11.1 The history of Morphic")
;; (find-squeakbyexpage (+ 16 235) "11.2 Manipulating morphs")
;; (find-squeakbyexpage (+ 16 236) "11.3 Composing morphs")
;; (find-squeakbyexpage (+ 16 237) "11.4 Creating and drawing your own morphs")
;; (find-squeakbyexpage (+ 16 241) "11.5 Interaction and animation")
;; (find-squeakbyexpage (+ 16 246) "11.6 Dialog windows")
;; (find-squeakbyexpage (+ 16 247) "11.7 Drag-and-drop")
;; (find-squeakbyexpage (+ 16 249) "11.8 A complete example")
;; (find-squeakbyexpage (+ 16 253) "11.9 More about the canvas")
;; (find-squeakbyexpage (+ 16 255) "11.10 Chapter summary.")
;; (find-squeakbyexpage (+ 16 259) "12 Classes and metaclasses")
;; (find-squeakbyexpage (+ 16 259) "12.1 Rules for classes and metaclasses")
;; (find-squeakbyexpage (+ 16 260) "12.2 Revisiting the Smalltalk object model")
;; (find-squeakbyexpage (+ 16 262) "12.3 Every class is an instance of a metaclass")
;; (find-squeakbyexpage (+ 16 263) "12.4 The metaclass hierarchy parallels the class hierarchy")
;; (find-squeakbyexpage (+ 16 266) "12.5 Every metaclass inherits from Class and Behavior")
;; (find-squeakbyexpage (+ 16 268) "12.6 Every metaclass is an instance of Metaclass")
;; (find-squeakbyexpage (+ 16 269) "12.7 The metaclass of Metaclass is an instance of Metaclass")
;; (find-squeakbyexpage (+ 16 270) "12.8 Chapter summary.")
;; (find-squeakbyexpage (+ 16 275) "A Frequently asked questions")
;; (find-squeakbyexpage (+ 16 275) "A.1 Getting started")
;; (find-squeakbyexpage (+ 16 276) "A.2 Collections")
;; (find-squeakbyexpage (+ 16 277) "A.3 Browsing the system")
;; (find-squeakbyexpage (+ 16 279) "A.4 Morphic")
;; (find-squeakbyexpage (+ 16 280) "A.5 System")
;; (find-squeakbyexpage (+ 16 280) "A.6 Using Monticello and SqueakSource")
;; (find-squeakbyexpage (+ 16 282) "A.7 Tools")
;; (find-squeakbyexpage (+ 16 283) "A.8 Regular expressions and parsing")
;; (find-squeakbyexpage (+ 16 285) "Bibliography")
;; «squeak-robots» (to ".squeak-robots")
;; (find-books "__comp/__comp.el" "squeak-robots")
(code-pdf-page "sqrobots" "~/books/__comp/ducasse__squeak_learning_programming_with_robots.pdf")
(code-pdf-text "sqrobots" "~/books/__comp/ducasse__squeak_learning_programming_with_robots.pdf" 25)
;; (find-sqrobotspage)
;; (find-sqrobotspage 4 "Contents")
;; (find-sqrobotstext 4 "Contents")
;; (find-sqrobotspage (+ 25 3) "1. Installation and Creating a Robot")
;; (find-sqrobotspage (+ 25 13) "2. A First Script and Its Implications")
;; (find-sqrobotspage (+ 25 29) "3. Of Robots and Men")
;; (find-sqrobotspage (+ 24 37) "4. Directions and Angles.")
;; (find-sqrobotspage (+ 23 51) "5. Pica's Environment")
;; (find-sqrobotspage (+ 23 61) "6. Fun with Robots")
;; (find-sqrobotspage (+ 21 77) "7. Looping")
;; (find-sqrobotspage (+ 21 87) "8. Variables")
;; (find-sqrobotspage (+ 20 101) "9. Digging Deeper into Variables")
;; (find-sqrobotspage (+ 20 109) "10. Loops and Variables")
;; (find-sqrobotspage (+ 20 119) "11. Composing Messages")
;; (find-sqrobotspage (+ 19 135) "12. Methods: Named Message Sequences")
;; (find-sqrobotspage (+ 18 149) "13. Combining Methods")
;; (find-sqrobotspage (+ 18 155) "14. Parameters and Arguments")
;; (find-sqrobotspage (+ 18 167) "15. Errors and Debugging")
;; (find-sqrobotspage (+ 17 183) "16. Decomposing to Recompose")
;; (find-sqrobotspage (+ 16 197) "17. Strings, and Tools for Understanding Programs")
;; (find-sqrobotspage (+ 15 209) "18. Conditions")
;; (find-sqrobotspage (+ 15 221) "19. Conditional Loops")
;; (find-sqrobotspage (+ 14 233) "20. Boolean and Boolean Expressions")
;; (find-sqrobotspage (+ 14 243) "21. Coordinates, Points, and Absolute Moves")
;; (find-sqrobotspage (+ 14 261) "22. Advanced Robot Behavior")
;; (find-sqrobotspage (+ 13 269) "23. Simulating Animal Behavior")
;; (find-sqrobotspage (+ 12 289) "24. A Tour of eToy")
;; (find-sqrobotspage (+ 12 315) "25. A Tour of Alice")
;; (find-sqrobotspage (+ 12 337) "Index")
;; (find-sqrobotstext "")
;; «pharo-by-example» (to ".pharo-by-example")
;; (find-es "pharo" "pharo-by-example")
(code-pdf-page "pharobyex" "$S/https/github.com/SquareBracketAssociates/PharoByExample9/releases/download/latest/PBE9-wip.pdf")
(code-pdf-text "pharobyex" "$S/https/github.com/SquareBracketAssociates/PharoByExample9/releases/download/latest/PBE9-wip.pdf" 18)
;; (find-pharobyexpage)
;; (find-pharobyextext)
;; (find-pharobyexpage 5 "Contents")
;; (find-pharobyextext 5 "Contents")
;; (find-pharobyexpage (+ 18 1) "1 About this book")
;; (find-pharobyexpage (+ 18 2) "1.1 What is Pharo?")
;; (find-pharobyexpage (+ 18 3) "1.2 Who should read this book?")
;; (find-pharobyexpage (+ 18 4) "1.3 A word of advice")
;; (find-pharobyexpage (+ 18 4) "1.4 An open book")
;; (find-pharobyexpage (+ 18 5) "1.5 The Pharo community")
;; (find-pharobyexpage (+ 18 5) "1.6 Examples and exercises")
;; (find-pharobyexpage (+ 18 6) "1.7 Typographic conventions")
;; (find-pharobyexpage (+ 18 6) "1.8 Acknowledgments")
;; (find-pharobyexpage (+ 18 7) "1.9 Hyper special acknowledgments")
;; (find-pharobyexpage (+ 18 9) "2 Getting Started with Pharo")
;; (find-pharobyexpage (+ 18 9) "2.1 Installing Pharo")
;; (find-pharobyexpage (+ 18 10) "2.2 File components")
;; (find-pharobyexpage (+ 18 11) "2.3 Launching Pharo with the Pharo Launcher")
;; (find-pharobyexpage (+ 18 12) "2.4 Launching Pharo via the command line")
;; (find-pharobyexpage (+ 18 14) "2.5 Saving, quitting and restarting a Pharo session")
;; (find-pharobyexpage (+ 18 15) "2.6 For the fast and furious")
;; (find-pharobyexpage (+ 18 16) "2.7 Chapter summary")
;; (find-pharobyexpage (+ 18 17) "3 A quick tour of Pharo")
;; (find-pharobyexpage (+ 18 17) "3.1 The World Menu")
;; (find-pharobyexpage (+ 18 18) "3.2 Interacting with Pharo")
;; (find-pharobyexpage (+ 18 20) "3.3 Playgrounds and Transcripts")
;; (find-pharobyexpage (+ 18 21) "3.4 Keyboard shortcuts")
;; (find-pharobyexpage (+ 18 21) "3.5 Doing vs. printing")
;; (find-pharobyexpage (+ 18 22) "3.6 Inspect")
;; (find-pharobyexpage (+ 18 23) "3.7 Other operations")
;; (find-pharobyexpage (+ 18 24) "3.8 Calypso: the System Browser")
;; (find-pharobyexpage (+ 18 26) "3.9 Chapter summary")
;; (find-pharobyexpage (+ 18 27) "4 Finding information in Pharo")
;; (find-pharobyexpage (+ 18 27) "4.1 Navigating using the System Browser")
;; (find-pharobyexpage (+ 18 28) "4.2 Finding classes")
;; (find-pharobyexpage (+ 18 30) "4.3 Finding methods")
;; (find-pharobyexpage (+ 18 32) "4.4 Finding Methods using Examples")
;; (find-pharobyexpage (+ 18 33) "4.5 Conclusion")
;; (find-pharobyexpage (+ 18 35) "5 A first tutorial: Developing a simple counter")
;; (find-pharobyexpage (+ 18 36) "5.1 Our use case")
;; (find-pharobyexpage (+ 18 36) "5.2 Create a package and class")
;; (find-pharobyexpage (+ 18 38) "5.3 Defining protocols and methods")
;; (find-pharobyexpage (+ 18 39) "5.4 Create a method")
;; (find-pharobyexpage (+ 18 41) "5.5 Adding a setter method")
;; (find-pharobyexpage (+ 18 41) "5.6 Define a Test Class")
;; (find-pharobyexpage (+ 18 43) "5.7 Saving your code as a git repository with Iceberg")
;; (find-pharobyexpage (+ 18 47) "5.8 Adding more messages")
;; (find-pharobyexpage (+ 18 47) "5.9 Instance initialization method")
;; (find-pharobyexpage (+ 18 48) "5.10 Define an initialize method")
;; (find-pharobyexpage (+ 18 49) "5.11 Define a new instance creation method")
;; (find-pharobyexpage (+ 18 50) "5.12 Better object description")
;; (find-pharobyexpage (+ 18 51) "5.13 Saving your code on a remote server")
;; (find-pharobyexpage (+ 18 53) "5.14 Conclusion")
;; (find-pharobyexpage (+ 18 55) "6 Building a little game")
;; (find-pharobyexpage (+ 18 56) "6.1 The Lights Out game")
;; (find-pharobyexpage (+ 18 56) "6.2 Creating a new package")
;; (find-pharobyexpage (+ 18 56) "6.3 Defining the class LOCell")
;; (find-pharobyexpage (+ 18 57) "6.4 Creating a new class")
;; (find-pharobyexpage (+ 18 58) "6.5 About comments")
;; (find-pharobyexpage (+ 18 59) "6.6 Adding methods to a class")
;; (find-pharobyexpage (+ 18 61) "6.7 Inspecting an object")
;; (find-pharobyexpage (+ 18 64) "6.8 Defining the class LOGame")
;; (find-pharobyexpage (+ 18 64) "6.9 Initializing our game")
;; (find-pharobyexpage (+ 18 65) "6.10 Taking advantage of the Debugger")
;; (find-pharobyexpage (+ 18 67) "6.11 Studying the initialize method")
;; (find-pharobyexpage (+ 18 69) "6.12 Organizing methods into protocols")
;; (find-pharobyexpage (+ 18 69) "6.13 Finishing the game")
;; (find-pharobyexpage (+ 18 71) "6.14 Final LOCell methods")
;; (find-pharobyexpage (+ 18 72) "6.15 Using the Debugger")
;; (find-pharobyexpage (+ 18 74) "6.16 And if all else fails...")
;; (find-pharobyexpage (+ 18 75) "6.17 Saving and sharing Pharo code")
;; (find-pharobyexpage (+ 18 75) "6.18 Writing code to files")
;; (find-pharobyexpage (+ 18 75) "6.19 Accessor conventions")
;; (find-pharobyexpage (+ 18 77) "6.20 Chapter summary")
;; (find-pharobyexpage (+ 18 79) "7 Publishing and packaging your first Pharo project")
;; (find-pharobyexpage (+ 18 79) "7.1 For the impatient")
;; (find-pharobyexpage (+ 18 80) "7.2 Basic architecture")
;; (find-pharobyexpage (+ 18 82) "7.3 Iceberg repositories browser")
;; (find-pharobyexpage (+ 18 83) "7.4 Add a new project to Iceberg")
;; (find-pharobyexpage (+ 18 87) "7.5 Add and commit your package using the 'Working copy' browser")
;; (find-pharobyexpage (+ 18 90) "7.6 What if I did not create a remote repository?")
;; (find-pharobyexpage (+ 18 92) "7.7 Configuring your project")
;; (find-pharobyexpage (+ 18 93) "7.8 Loading from an existing repository")
;; (find-pharobyexpage (+ 18 94) "7.9 Stepping back...")
;; (find-pharobyexpage (+ 18 95) "7.10 Conclusion")
;; (find-pharobyexpage (+ 18 97) "8 Syntax in a nutshell")
;; (find-pharobyexpage (+ 18 97) "8.1 Syntactic elements")
;; (find-pharobyexpage (+ 18 101) "8.2 Pseudo-variables")
;; (find-pharobyexpage (+ 18 101) "8.3 Messages and message sends")
;; (find-pharobyexpage (+ 18 102) "8.4 Sequences and cascades")
;; (find-pharobyexpage (+ 18 103) "8.5 Method syntax")
;; (find-pharobyexpage (+ 18 104) "8.6 Block syntax")
;; (find-pharobyexpage (+ 18 105) "8.7 Conditionals and loops")
;; (find-pharobyexpage (+ 18 107) "8.8 Method annotations: Primitives and pragmas")
;; (find-pharobyexpage (+ 18 108) "8.9 Chapter summary")
;; (find-pharobyexpage (+ 18 111) "9 Understanding message syntax")
;; (find-pharobyexpage (+ 18 111) "9.1 Identifying messages")
;; (find-pharobyexpage (+ 18 113) "9.2 Three kinds of messages")
;; (find-pharobyexpage (+ 18 116) "9.3 Message composition")
;; (find-pharobyexpage (+ 18 122) "9.4 Hints for identifying keyword messages")
;; (find-pharobyexpage (+ 18 124) "9.5 Expression sequences")
;; (find-pharobyexpage (+ 18 124) "9.6 Cascaded messages")
;; (find-pharobyexpage (+ 18 125) "9.7 Chapter summary")
;; (find-pharobyexpage (+ 18 127) "10 The Pharo object model")
;; (find-pharobyexpage (+ 18 127) "10.1 The rules of the core model")
;; (find-pharobyexpage (+ 18 128) "10.2 Everything is an Object")
;; (find-pharobyexpage (+ 18 129) "10.3 Every object is an instance of a class")
;; (find-pharobyexpage (+ 18 129) "10.4 Instance structure and behavior")
;; (find-pharobyexpage (+ 18 131) "10.5 Every class has a superclass")
;; (find-pharobyexpage (+ 18 132) "10.6 Everything happens by sending messages")
;; (find-pharobyexpage (+ 18 134) "10.7 Sending a message: a two-step process")
;; (find-pharobyexpage (+ 18 135) "10.8 Method lookup follows the inheritance chain")
;; (find-pharobyexpage (+ 18 135) "10.9 Method execution")
;; (find-pharobyexpage (+ 18 137) "10.10 Message not understood")
;; (find-pharobyexpage (+ 18 138) "10.11 About returning self")
;; (find-pharobyexpage (+ 18 138) "10.12 Overriding and extension")
;; (find-pharobyexpage (+ 18 139) "10.13 Self and super sends")
;; (find-pharobyexpage (+ 18 141) "10.14 Stepping back")
;; (find-pharobyexpage (+ 18 142) "10.15 The instance and class sides")
;; (find-pharobyexpage (+ 18 144) "10.16 Class methods")
;; (find-pharobyexpage (+ 18 145) "10.17 Class instance variables")
;; (find-pharobyexpage (+ 18 145) "10.18 Example: Class instance variables and subclasses")
;; (find-pharobyexpage (+ 18 147) "10.19 Stepping back")
;; (find-pharobyexpage (+ 18 147) "10.20 Example: Defining a Singleton")
;; (find-pharobyexpage (+ 18 149) "10.21 A note on lazy initialization")
;; (find-pharobyexpage (+ 18 149) "10.22 Shared variables")
;; (find-pharobyexpage (+ 18 151) "10.23 Class variables: Shared variables")
;; (find-pharobyexpage (+ 18 153) "10.24 Pool variables")
;; (find-pharobyexpage (+ 18 154) "10.25 Abstract methods and abstract classes")
;; (find-pharobyexpage (+ 18 154) "10.26 Example: the abstract class Magnitude")
;; (find-pharobyexpage (+ 18 155) "10.27 Chapter summary")
;; (find-pharobyexpage (+ 18 157) "11 Traits: reusable class fragments")
;; (find-pharobyexpage (+ 18 157) "11.1 A simple trait")
;; (find-pharobyexpage (+ 18 158) "11.2 Using a required method")
;; (find-pharobyexpage (+ 18 159) "11.3 Self in a trait is the message receiver")
;; (find-pharobyexpage (+ 18 159) "11.4 Trait state")
;; (find-pharobyexpage (+ 18 160) "11.5 A class can use two traits")
;; (find-pharobyexpage (+ 18 161) "11.6 Overriding method takes precedence over trait methods")
;; (find-pharobyexpage (+ 18 162) "11.7 Accessing overridden trait methods")
;; (find-pharobyexpage (+ 18 162) "11.8 Handling conflict")
;; (find-pharobyexpage (+ 18 163) "11.9 Conflict resolution: excluding a method")
;; (find-pharobyexpage (+ 18 164) "11.10 Conflict resolution: redefining the method")
;; (find-pharobyexpage (+ 18 164) "11.11 Conclusion")
;; (find-pharobyexpage (+ 18 165) "12 SUnit: Tests in Pharo")
;; (find-pharobyexpage (+ 18 165) "12.1 Introduction")
;; (find-pharobyexpage (+ 18 166) "12.2 Why testing is important")
;; (find-pharobyexpage (+ 18 167) "12.3 What makes a good test?")
;; (find-pharobyexpage (+ 18 167) "12.4 SUnit step by step")
;; (find-pharobyexpage (+ 18 168) "12.5 Step 1: Create the test class")
;; (find-pharobyexpage (+ 18 168) "12.6 Step 2: Initialize the test context")
;; (find-pharobyexpage (+ 18 168) "12.7 Step 3: Write some test methods")
;; (find-pharobyexpage (+ 18 169) "12.8 Step 4: Run the tests")
;; (find-pharobyexpage (+ 18 170) "12.9 Step 5: Interpret the results")
;; (find-pharobyexpage (+ 18 171) "12.10 Using assert:equals:")
;; (find-pharobyexpage (+ 18 171) "12.11 Skipping a test")
;; (find-pharobyexpage (+ 18 172) "12.12 Asserting exceptions")
;; (find-pharobyexpage (+ 18 172) "12.13 Programmatically running tests")
;; (find-pharobyexpage (+ 18 173) "12.14 Conclusion")
;; (find-pharobyexpage (+ 18 175) "13 Basic classes")
;; (find-pharobyexpage (+ 18 175) "13.1 Object")
;; (find-pharobyexpage (+ 18 176) "13.2 Object printing")
;; (find-pharobyexpage (+ 18 177) "13.3 Representation and self-evaluating representation")
;; (find-pharobyexpage (+ 18 179) "13.4 Identity and equality")
;; (find-pharobyexpage (+ 18 180) "13.5 Class membership")
;; (find-pharobyexpage (+ 18 181) "13.6 About isKindOf: and respondTo:")
;; (find-pharobyexpage (+ 18 181) "13.7 Shallow copying objects")
;; (find-pharobyexpage (+ 18 181) "13.8 Deep copying objects")
;; (find-pharobyexpage (+ 18 182) "13.9 Debugging")
;; (find-pharobyexpage (+ 18 183) "13.10 Error handling")
;; (find-pharobyexpage (+ 18 185) "13.11 Testing")
;; (find-pharobyexpage (+ 18 185) "13.12 Initialize")
;; (find-pharobyexpage (+ 18 186) "13.13 Numbers")
;; (find-pharobyexpage (+ 18 187) "13.14 Magnitude")
;; (find-pharobyexpage (+ 18 187) "13.15 Numbers")
;; (find-pharobyexpage (+ 18 188) "13.16 Floats")
;; (find-pharobyexpage (+ 18 189) "13.17 Fractions")
;; (find-pharobyexpage (+ 18 189) "13.18 Integers")
;; (find-pharobyexpage (+ 18 190) "13.19 Characters")
;; (find-pharobyexpage (+ 18 191) "13.20 Strings")
;; (find-pharobyexpage (+ 18 193) "13.21 Booleans")
;; (find-pharobyexpage (+ 18 194) "13.22 Chapter summary")
;; (find-pharobyexpage (+ 18 197) "14 Collections")
;; (find-pharobyexpage (+ 18 198) "14.1 High-order functions")
;; (find-pharobyexpage (+ 18 199) "14.2 The varieties of collections")
;; (find-pharobyexpage (+ 18 200) "14.3 Collection implementations")
;; (find-pharobyexpage (+ 18 201) "14.4 Examples of key classes")
;; (find-pharobyexpage (+ 18 202) "14.5 Common creation protocol")
;; (find-pharobyexpage (+ 18 203) "14.6 Array")
;; (find-pharobyexpage (+ 18 205) "14.7 OrderedCollection")
;; (find-pharobyexpage (+ 18 206) "14.8 Interval")
;; (find-pharobyexpage (+ 18 206) "14.9 Dictionary")
;; (find-pharobyexpage (+ 18 207) "14.10 IdentityDictionary")
;; (find-pharobyexpage (+ 18 208) "14.11 Set")
;; (find-pharobyexpage (+ 18 209) "14.12 SortedCollection")
;; (find-pharobyexpage (+ 18 210) "14.13 Strings")
;; (find-pharobyexpage (+ 18 215) "14.14 Collection iterators")
;; (find-pharobyexpage (+ 18 216) "14.15 Collecting results (collect:)")
;; (find-pharobyexpage (+ 18 218) "14.16 Selecting and rejecting elements")
;; (find-pharobyexpage (+ 18 219) "14.17 Other high-order messages")
;; (find-pharobyexpage (+ 18 219) "14.18 A common mistake: using add: result")
;; (find-pharobyexpage (+ 18 220) "14.19 A common mistake: Removing an element while iterating")
;; (find-pharobyexpage (+ 18 220) "14.20 A common mitaske: Redefining = but not hash")
;; (find-pharobyexpage (+ 18 221) "14.21 Chapter summary")
;; (find-pharobyexpage (+ 18 223) "15 Streams")
;; (find-pharobyexpage (+ 18 223) "15.1 Two sequences of elements")
;; (find-pharobyexpage (+ 18 224) "15.2 Streams vs. collections")
;; (find-pharobyexpage (+ 18 225) "15.3 Reading collections")
;; (find-pharobyexpage (+ 18 226) "15.4 Peek")
;; (find-pharobyexpage (+ 18 227) "15.5 Positioning to an index")
;; (find-pharobyexpage (+ 18 227) "15.6 Skipping elements")
;; (find-pharobyexpage (+ 18 228) "15.7 Predicates")
;; (find-pharobyexpage (+ 18 229) "15.8 Writing to collections")
;; (find-pharobyexpage (+ 18 230) "15.9 About string concatenation")
;; (find-pharobyexpage (+ 18 231) "15.10 About printString")
;; (find-pharobyexpage (+ 18 233) "15.11 Reading and writing at the same time")
;; (find-pharobyexpage (+ 18 236) "15.12 Chapter summary")
;; (find-pharobyexpage (+ 18 237) "16 Morphic")
;; (find-pharobyexpage (+ 18 237) "16.1 The history of Morphic")
;; (find-pharobyexpage (+ 18 238) "16.2 Morphs")
;; (find-pharobyexpage (+ 18 240) "16.3 Manipulating morphs")
;; (find-pharobyexpage (+ 18 241) "16.4 Composing morphs")
;; (find-pharobyexpage (+ 18 242) "16.5 Creating and drawing your own morphs")
;; (find-pharobyexpage (+ 18 246) "16.6 Mouse events for interaction")
;; (find-pharobyexpage (+ 18 247) "16.7 Keyboard events")
;; (find-pharobyexpage (+ 18 248) "16.8 Morphic animations")
;; (find-pharobyexpage (+ 18 249) "16.9 Interactors")
;; (find-pharobyexpage (+ 18 250) "16.10 Drag-and-drop")
;; (find-pharobyexpage (+ 18 253) "16.11 A complete example")
;; (find-pharobyexpage (+ 18 257) "16.12 More about the canvas")
;; (find-pharobyexpage (+ 18 258) "16.13 Chapter summary")
;; (find-pharobyexpage (+ 18 259) "17 Classes and metaclasses")
;; (find-pharobyexpage (+ 18 259) "17.1 Rules for classes")
;; (find-pharobyexpage (+ 18 260) "17.2 Metaclasses")
;; (find-pharobyexpage (+ 18 260) "17.3 Revisiting the Pharo object model")
;; (find-pharobyexpage (+ 18 261) "17.4 Every class is an instance of a metaclass")
;; (find-pharobyexpage (+ 18 263) "17.5 Querying Metaclasses")
;; (find-pharobyexpage (+ 18 263) "17.6 The metaclass hierarchy parallels the class hierarchy")
;; (find-pharobyexpage (+ 18 264) "17.7 Uniformity between Classes and Objects")
;; (find-pharobyexpage (+ 18 266) "17.8 Inspecting objects and classes")
;; (find-pharobyexpage (+ 18 266) "17.9 Every metaclass inherits from Class and Behavior")
;; (find-pharobyexpage (+ 18 268) "17.10 Responsibilities of Behavior, ClassDescription, and Class")
;; (find-pharobyexpage (+ 18 269) "17.11 Every metaclass is an instance of Metaclass")
;; (find-pharobyexpage (+ 18 269) "17.12 The metaclass of Metaclass is an instance of Metaclass")
;; (find-pharobyexpage (+ 18 271) "17.13 Chapter summary")
;; (find-pharobyexpage (+ 18 273) "18 Reflection")
;; (find-pharobyexpage (+ 18 273) "18.1 Reflection in a nutshell")
;; (find-pharobyexpage (+ 18 274) "18.2 Introspection")
;; (find-pharobyexpage (+ 18 275) "18.3 Accessing instance variables")
;; (find-pharobyexpage (+ 18 276) "18.4 About reflective behavior")
;; (find-pharobyexpage (+ 18 277) "18.5 About primitives")
;; (find-pharobyexpage (+ 18 277) "18.6 Querying classes and interfaces")
;; (find-pharobyexpage (+ 18 278) "18.7 Simple code metrics")
;; (find-pharobyexpage (+ 18 279) "18.8 Browsing instances")
;; (find-pharobyexpage (+ 18 280) "18.9 From methods to instance variables")
;; (find-pharobyexpage (+ 18 281) "18.10 About SystemNavigation")
;; (find-pharobyexpage (+ 18 282) "18.11 Classes, method dictionaries, and methods")
;; (find-pharobyexpage (+ 18 285) "18.12 Browsing environments")
;; (find-pharobyexpage (+ 18 286) "18.13 Pragmas: method annotation")
;; (find-pharobyexpage (+ 18 288) "18.14 Accessing the run-time context")
;; (find-pharobyexpage (+ 18 289) "18.15 Intelligent contextual breakpoints")
;; (find-pharobyexpage (+ 18 291) "18.16 Intercepting not understood messages")
;; (find-pharobyexpage (+ 18 291) "18.17 Lightweight proxies")
;; (find-pharobyexpage (+ 18 294) "18.18 Generating missing methods")
;; (find-pharobyexpage (+ 18 296) "18.19 Objects as method wrappers")
;; (find-pharobyexpage (+ 18 297) "18.20 Chapter summary")
;; «ingalls-miranda» (to ".ingalls-miranda")
;; (find-books "__comp/__comp.el" "ingalls-miranda")
(code-pdf-page "tdlc" "~/books/__comp/ingalls_miranda__two_decades_of_live_coding_and_debugging_of_vms_through_simulation.pdf")
(code-pdf-text "tdlc" "~/books/__comp/ingalls_miranda__two_decades_of_live_coding_and_debugging_of_vms_through_simulation.pdf" 1)
(code-pdf-page "tdsvd" "~/books/__comp/ingalls_miranda__two_decades_of_smalltalk_vm_development.pdf")
(code-pdf-text "tdsvd" "~/books/__comp/ingalls_miranda__two_decades_of_smalltalk_vm_development.pdf" 1)
;; (find-tdlcpage)
;; (find-tdlcpage 1 "Contents")
;; (find-tdlcpage (+ 1 189) "Index")
;; (find-tdlctext "")
;; (find-tdsvdpage)
;; (find-tdsvdpage 1 "Contents")
;; (find-tdsvdpage (+ 1 189) "Index")
;; (find-tdsvdtext "")
;; «st-by-ex» (to ".st-by-ex")
;; (find-books "__comp/__comp.el" "st-by-ex")
;; https://rmod-files.lille.inria.fr/FreeBooks/ByExample/
;; https://rmod-files.lille.inria.fr/FreeBooks/ByExample/SmalltalkByExampleON2.pdf
;; https://rmod-files.lille.inria.fr/FreeBooks/ByExample/SmalltalkByExampleNewRelease.pdf
(code-pdf-page "stbyex" "$S/https/rmod-files.lille.inria.fr/FreeBooks/ByExample/SmalltalkByExampleON2.pdf")
(code-pdf-text "stbyex" "$S/https/rmod-files.lille.inria.fr/FreeBooks/ByExample/SmalltalkByExampleON2.pdf")
(code-pdf-page "stbyex" "$S/https/rmod-files.lille.inria.fr/FreeBooks/ByExample/SmalltalkByExampleNewRelease.pdf")
(code-pdf-text "stbyex" "$S/https/rmod-files.lille.inria.fr/FreeBooks/ByExample/SmalltalkByExampleNewRelease.pdf")
;; (find-stbyexpage)
;; (find-stbyextext)
;; (find-stbyexpage (+ 3 1) "Introduction")
;; (find-stbyextext (+ 3 1) "Introduction")
;; (find-stbyexpage (+ 9 1) "1" "Basic Concepts")
;; (find-stbyextext (+ 9 1) "1" "Basic Concepts")
;; (find-stbyexpage (+ 16 1) "2" "Messages")
;; (find-stbyextext (+ 16 1) "2" "Messages")
;; (find-stbyexpage (+ 22 1) "3" "Methods")
;; (find-stbyextext (+ 22 1) "3" "Methods")
;; (find-stbyexpage (+ 29 1) "4" "Variables")
;; (find-stbyextext (+ 29 1) "4" "Variables")
;; (find-stbyexpage (+ 43 1) "5" "Instance Creation")
;; (find-stbyextext (+ 43 1) "5" "Instance Creation")
;; (find-stbyexpage (+ 48 1) "6" "Special Variables, Characters, and" "Symbols")
;; (find-stbyextext (+ 48 1) "6" "Special Variables, Characters, and" "Symbols")
;; (find-stbyexpage (+ 55 1) "7" "Global Variables")
;; (find-stbyextext (+ 55 1) "7" "Global Variables")
;; (find-stbyexpage (+ 60 1) "8" "Control Structures")
;; (find-stbyextext (+ 60 1) "8" "Control Structures")
;; (find-stbyexpage (+ 64 1) "9" "Object-Oriented Thinking")
;; (find-stbyextext (+ 64 1) "9" "Object-Oriented Thinking")
;; (find-stbyexpage (+ 70 1) "10" "Object")
;; (find-stbyextext (+ 70 1) "10" "Object")
;; (find-stbyexpage (+ 75 1) "11" "Collections")
;; (find-stbyextext (+ 75 1) "11" "Collections")
;; (find-stbyexpage (+ 89 1) "12" "Strings")
;; (find-stbyextext (+ 89 1) "12" "Strings")
;; (find-stbyexpage (+ 96 1) "13" "Streams")
;; (find-stbyextext (+ 96 1) "13" "Streams")
;; (find-stbyexpage (+ 102 1) "14" "Files")
;; (find-stbyextext (+ 102 1) "14" "Files")
;; (find-stbyexpage (+ 109 1) "15" "Printing Objects")
;; (find-stbyextext (+ 109 1) "15" "Printing Objects")
;; (find-stbyexpage (+ 113 1) "16" "Processes")
;; (find-stbyextext (+ 113 1) "16" "Processes")
;; (find-stbyexpage (+ 122 1) "17" "Coordinating and Sequencing events")
;; (find-stbyextext (+ 122 1) "17" "Coordinating and Sequencing events")
;; (find-stbyexpage (+ 127 1) "18" "Cleaning up at Termination")
;; (find-stbyextext (+ 127 1) "18" "Cleaning up at Termination")
;; (find-stbyexpage (+ 130 1) "19" "The Dependency Mechanism")
;; (find-stbyextext (+ 130 1) "19" "The Dependency Mechanism")
;; (find-stbyexpage (+ 141 1) "20" "Error Handling")
;; (find-stbyextext (+ 141 1) "20" "Error Handling")
;; (find-stbyexpage (+ 156 1) "21" "Debugging")
;; (find-stbyextext (+ 156 1) "21" "Debugging")
;; (find-stbyexpage (+ 168 1) "22" "Common Errors")
;; (find-stbyextext (+ 168 1) "22" "Common Errors")
;; (find-stbyexpage (+ 175 1) "23" "Model-View-Controller")
;; (find-stbyextext (+ 175 1) "23" "Model-View-Controller")
;; (find-stbyexpage (+ 182 1) "24" "MVC Dependencies")
;; (find-stbyextext (+ 182 1) "24" "MVC Dependencies")
;; (find-stbyexpage (+ 196 1) "25" "Hooks into the System")
;; (find-stbyextext (+ 196 1) "25" "Hooks into the System")
;; (find-stbyexpage (+ 203 1) "26" "Changing Widgets at Runtime")
;; (find-stbyextext (+ 203 1) "26" "Changing Widgets at Runtime")
;; (find-stbyexpage (+ 214 1) "27" "Extending the Application Framework")
;; (find-stbyextext (+ 214 1) "27" "Extending the Application Framework")
;; (find-stbyexpage (+ 218 1) "28" "Eliminating Procedural Code")
;; (find-stbyextext (+ 218 1) "28" "Eliminating Procedural Code")
;; (find-stbyexpage (+ 223 1) "29" "Meta-Programming")
;; (find-stbyextext (+ 223 1) "29" "Meta-Programming")
;; (find-stbyexpage (+ 230 1) "30" "Testing")
;; (find-stbyextext (+ 230 1) "30" "Testing")
;; (find-stbyexpage (+ 242 1) "31" "Customizing your Environment")
;; (find-stbyextext (+ 242 1) "31" "Customizing your Environment")
;; (find-stbyexpage (+ 253 1) "32" "Changes to System Classes")
;; (find-stbyextext (+ 253 1) "32" "Changes to System Classes")
;; (find-stbyexpage (+ 257 1) "33" "Managing Source Code")
;; (find-stbyextext (+ 257 1) "33" "Managing Source Code")
;; (find-stbyexpage (+ 269 1) "34" "ENVY")
;; (find-stbyextext (+ 269 1) "34" "ENVY")
;; (find-stbyexpage (+ 277 1) "35" "Public Domain Code and" "Information")
;; (find-stbyextext (+ 277 1) "35" "Public Domain Code and" "Information")
;; (find-stbyexpage (+ 280 1) "A" "Source Files")
;; (find-stbyextext (+ 280 1) "A" "Source Files")
;; (find-stbyexpage (+ 283 1) "B" "Source Code for" "Chapter 24")
;; (find-stbyextext (+ 283 1) "B" "Source Code for" "Chapter 24")
;; «byte-smalltalk» (to ".byte-smalltalk")
;; https://ia802700.us.archive.org/8/items/byte-magazine-1981-08/1981_08_BYTE_06-08_Smalltalk.pdf
(code-pdf-page "byte81st" "$S/https/ia802700.us.archive.org/8/items/byte-magazine-1981-08/1981_08_BYTE_06-08_Smalltalk.pdf")
(code-pdf-text "byte81st" "$S/https/ia802700.us.archive.org/8/items/byte-magazine-1981-08/1981_08_BYTE_06-08_Smalltalk.pdf")
;; (find-byte81stpage)
;; (find-byte81stpage 5 "Contents")
;; (find-byte81stpage (+ 2 14) "Introducing")
;; (find-byte81stpage (+ 2 36) "The SmallTalk-80 System")
;; (find-byte81sttext)
;; (find-byte81sttext 16)
;; «ssh» (to ".ssh")
;; http://gigapedia.com/items/4269/ssh--the-secure-shell---the-definitive-guide--2nd-edition--2005-01
(code-xpdf "snailbook" "~/books/__comp/barrett_silverman__ssh_the_secure_shell_2ed.pdf")
(code-pdftotext "snailbook" "~/books/__comp/barrett_silverman__ssh_the_secure_shell_2ed.pdf" 16)
;; (ee-page-parameters "snailbook" 16)
;; (find-snailbookpage 5 "Contents")
;; (find-snailbookpage (+ 16 26) "2.4. Authentication by Cryptographic Key")
;; (find-snailbooktext (+ 16 26) "2.4. Authentication by Cryptographic Key")
;; (find-snailbookpage (+ 16 32) "2.5. The SSH Agent")
;; (find-snailbooktext (+ 16 32) "2.5. The SSH Agent")
;; (find-snailbookpage (+ 16 37) "2.6. Connecting Without a Password")
;; (find-snailbooktext "2.6. Connecting Without a Password")
;; (find-snailbookpage (+ 16 60) "3.4.2.3. Trusted-host authentication")
;; (find-snailbooktext "3.4.2.3. Trusted-host authentication")
;; (find-snailbookpage (+ 16 521) "Index")
;; (find-snailbooktext "Index")
;; «unixtools» (to ".unixtools")
;; (find-books "__comp/__comp.el" "unixtools")
;; Markus Kuhn: "Unix Tools" (course at the Cambridge Computer Lab)
;; https://www.cl.cam.ac.uk/teaching/1516/UnixTools/
;; https://www.cl.cam.ac.uk/teaching/1516/UnixTools/unixtools-slides.pdf
;; https://www.cl.cam.ac.uk/teaching/1516/UnixTools/notes.pdf
(code-pdf-page "unixtoolss" "$S/https/www.cl.cam.ac.uk/teaching/1516/UnixTools/unixtools-slides.pdf")
(code-pdf-text "unixtoolss" "$S/https/www.cl.cam.ac.uk/teaching/1516/UnixTools/unixtools-slides.pdf")
(code-pdf-page "unixtoolsn" "$S/https/www.cl.cam.ac.uk/teaching/1516/UnixTools/notes.pdf")
(code-pdf-text "unixtoolsn" "$S/https/www.cl.cam.ac.uk/teaching/1516/UnixTools/notes.pdf")
;; (find-unixtoolsspage)
;; (find-unixtoolsstext)
;; (find-unixtoolsnpage)
;; (find-unixtoolsntext)
;; «unix-haters» (to ".unix-haters")
;; (find-books "__comp/__comp.el" "unix-haters")
;; https://en.wikipedia.org/wiki/The_UNIX-HATERS_Handbook
;; https://web.mit.edu/~simsong/www/ugh.pdf
;; https://www.reddit.com/r/programming/comments/74cws/the_unix_haters_handbook_reconsidered/
;; https://news.ycombinator.com/item?id=19416485 The Unix-Haters Handbook (1994) [pdf] (web.mit.edu)
;; https://news.ycombinator.com/item?id=13781815 The Unix-Haters Handbook (1994) [pdf] (web.mit.edu)
;; https://news.ycombinator.com/item?id=7726115 The Unix Haters Handbook (1994) [pdf] (web.mit.edu)
(code-pdf-page "unixhaters" "$S/https/web.mit.edu/~simsong/www/ugh.pdf")
(code-pdf-text "unixhaters" "$S/https/web.mit.edu/~simsong/www/ugh.pdf" 40)
;; (find-unixhaterspage)
;; (find-unixhaterstext)
;; (find-unixhaterspage 11 "Table of Contents")
;; (find-unixhaterstext 11 "Table of Contents")
;; (find-unixhaterspage (+ 38 148) "The Shell Game")
;; (find-unixhaterstext (+ 38 148) "The Shell Game")
;; «unusual-effectiveness» (to ".unusual-effectiveness")
;; (find-books "__comp/__comp.el" "unusual-effectiveness")
;; https://www.cs.cmu.edu/~rwh/papers/unreasonable/basl.pdf
;; Halpern/Harper/Immerman/Kolaitis/Vardi/Vian:
;; "On the Unusual Effectiveness of Logic in Computer Science"
(code-pdf-page "unusualeff" "$S/https/www.cs.cmu.edu/~rwh/papers/unreasonable/basl.pdf")
(code-pdf-text "unusualeff" "$S/https/www.cs.cmu.edu/~rwh/papers/unreasonable/basl.pdf")
;; (find-unusualeffpage)
;; (find-unusualefftext)
;;
;; [Wig60] E.P. Wigner. The unreasonable effectiveness of mathematics
;; in the natural sciences. Comm. on Pure and Applied Math.,
;; 13:1-14, 1960.
;;
;; [Ham80] R.W. Hamming. The unreasonable effectiveness of
;; mathematics. American Mathematical Monthly, 87:8190, 1980.
;; http://gigapedia.com/items/5208/advanced-programming-language-design
(code-xpdf "finkel" "~/books/__comp/finkel__advanced_programming_languages_design.pdf")
(code-pdftotext "finkel" "~/books/__comp/finkel__advanced_programming_languages_design.pdf")
;; (find-finkelpage 1 "Contents")
;; (find-finkelpage (+ 7 351) "3.19 Continuations")
;; (find-finkeltext )
;; Very incomplete
(code-xpdf "sebesta" "~/books/__comp/sebesta__concepts_of_programming_languages.pdf")
;; (find-sebestapage 7 "Contents")
;; (find-sebestapage (+ -1 677) "Index")
(code-xpdf "stevensonplf" "~/books/__comp/stevenson__programming_language_fundamentals_by_example.pdf")
(code-pdftotext "stevensonplf" "~/books/__comp/stevenson__programming_language_fundamentals_by_example.pdf")
;; (find-stevensonplfpage 6 "Contents")
;; (find-stevensonplfpage (+ 16 1) "1. A word about using this text")
;; (find-stevensonplfpage (+ 16 37) "Milestone I\n" "LEARNING A NEW" "LANGUAGE, Gforth")
;; (find-stevensonplftext "Milestone I\n" "LEARNING A NEW" "LANGUAGE, Gforth")
;; (find-stevensonplftext "")
;; http://gigapedia.com/items/194905/design-concepts-in-programming-languages
(code-xpdf "turbakgifford" "~/books/__comp/turbak_gifford__design_concepts_in_programming_languages.pdf")
(code-pdftotext "turbakgifford" "~/books/__comp/turbak_gifford__design_concepts_in_programming_languages.pdf")
;; (find-turbakgiffordpage 6 "Contents")
;; (find-turbakgiffordpage (+ 25 1227) "Index")
;; (find-turbakgiffordtext "")
;; ~/books/__comp/gang_of_four__design_patterns.chm
;; (find-unpack-chm-links "~/books/__comp/gang_of_four__design_patterns.chm" "/tmp/designpats/" "designpats")
(code-c-d "designpats" "/tmp/designpats/")
;; (find-designpatsfile "")
;; (find-designpatsw3m "00.htm")
;; http://gigapedia.com/items/17653/concepts--techniques--and-models-of-computer-programming
(code-xpdf "vanroyharidi" "~/books/__comp/van_roy_haridi__concepts_techniques_and_models_of_computer_programming.pdf")
;; (find-vanroyharidipage 8 "Contents")
;; (find-vanroyharidipage (+ 31 863) "Index")
;; http://gigapedia.com/items/206006/forth-encyclopedia--the-complete-forth-programmer--039-s-manual
(code-xpdf "forthencyclopedia" "~/books/__comp/derick_baker__forth_encyclopedia.pdf")
;; (find-forthencyclopediapage 4 "Contents")
;; (find-forthencyclopediapage (+ 12 331) "Index")
;; http://gigapedia.com/items/115838/theorem-proving-in-higher-order-logics--10th-international-conference--tphols--039-97--murray-hill--nj--usa--august-19-22--1997--proceedings--lecture-notes-in-computer-science-
;; "Theorem Proving in Higher Order Logics": TPHOLs'97, LNCS 1275
(code-xpdf "tphol" "~/books/__comp/gunter_felty__theorem_proving_in_higher_order_logic.pdf")
;; (find-tpholpage 6 "Contents")
;; (find-tpholpage (+ 7 1) "Index")
;; (find-tpholpage (+ 1 199) "On Formalization of Bicategory Theory")
;; http://gigapedia.com/items/335403/theoretical-computer-science--volume-375--issues-1-3--pages-1-350--1-may-2007---festschrift-for-john-c--reynolds---s-70th-birthday
(code-xpdf "tcs375" "~/books/__comp/tcs_375__john_c_reynolds_festschrift.pdf")
;; (find-tcs375page (+ 5 3) "A fibrational framework...")
;; (find-tcs375page (+ 5 20) "Combining algebraic effects with continuations")
;; (find-tcs375page (+ 5 42) "On the relations between monadic semantics")
;; (find-tcs375page (+ 5 76) "A syntactic correspondence...")
;; (find-tcs375page (+ 5 193) "Core algebra revisited")
;; (find-tcs375page (+ 5 201) "The Girard-Reynolds isomorphism")
;; (find-tcs375page (+ 5 335) "A few exercises in theorem processing")
;; http://gigapedia.com/items/335399/theoretical-computer-science--volume-316--issues-1-3--pages-1-323--28-may-2004---recent-developments-in-domain-theory--a-collection-of-papers-in-honour-of-dana-s--scott
(code-xpdf "tcs316" "~/books/__comp/tcs_316__in_honour_of_dana_scott.pdf")
;; (find-tcs316page 1 "Contents")
;; (find-tcs316page (+ 1 105) "Lawvere" "Left and right adjoint operations on spaces and data types")
;; (find-tcs316page (+ 1 112) "Gentzen")
;; (find-tcs316page (+ 1 189) "Streicher")
;; (find-tcs316page 320 "Author index")
;; http://gigapedia.com/items/104785/edinburgh-lcf--a-mechanized-logic-of-computation--lecture-notes-in-computer-science-
(code-xpdf "gmwelcf" "~/books/__comp/gordon_milner_wadsworth__edinburgh_lcf.pdf")
;; (find-gmwelcfpage 7 "Contents")
;; (find-gmwelcfpage (+ 8 158) "Index")
;; http://gigapedia.com/items/36701/isabelle-hol--a-proof-assistant-for-higher-order-logic--lecture-notes-in-computer-science-2283-
(code-xpdf "npwisahol" "~/books/__comp/nipkow_paulson_wenzel__isabelle_hol.pdf")
;; (find-npwisaholpage 6 "Contents")
;; (find-npwisaholpage (+ 11 214) "Index")
;; http://gigapedia.com/items/258668/proof--language--and-interaction--essays-in-honour-of-robin-milner--foundations-of-computing-
(code-xpdf "plandi" "~/books/__comp/plotkin_stirling_tofte__proof_language_and_interaction.pdf")
;; (find-plandipage 6 "Contents")
;; (find-plandipage (+ 15 169) "From LCF to HOL: a short history")
;; (find-plandipage (+ 15 239) "Constructive Category Theory")
;; (find-plandipage (+ 15 721) "Contributors")
;; http://gigapedia.com/items/66716/beautiful-code--leading-programmers-explain-how-they-think--theory-in-practice--o--039-reilly--
;; (find-unpack-chm-links "~/books/__comp/oram_wilson__beautiful_code.chm" "/tmp/beautifulcode/" "beautifulcode")
(code-c-d "beautifulcode" "/tmp/beautifulcode/")
;; (find-beautifulcodefile "")
;; (find-beautifulcodew3m "000.toc.html")
;; (find-beautifulcodew3m "246.index.html")
;; http://gigapedia.com/items/111804/the-little-lisper---3rd-edition
(code-djvu "littlelisper" "~/books/__comp/friedman_felleisen__the_little_lisper.djvu")
;; (find-littlelisperpage 4 "vii" "Contents")
;; (find-littlelisperpage 108 "205" "Index")
;; http://gigapedia.com/items/137595/the-art-of-the-metaobject-protocol
(code-djvu "taotmp" "~/books/__comp/kiczales__the_art_of_the_metaobject_protocol.djvu")
;; (find-taotmppage 2 "Contents")
;; (find-taotmppage (+ -5 327) "Index")
;; http://gigapedia.com/items/360364/masterminds-of-programming--conversations-with-the-creators-of-major-programming-languages--theory-in-practice--o--039-reilly--
(code-xpdf "masterminds" "~/books/__comp/biancuzzi_warden__masterminds_of_programming.pdf")
(code-pdftotext "masterminds" "~/books/__comp/biancuzzi_warden__masterminds_of_programming.pdf")
;; (find-mastermindspage 5 "Contents")
;; (find-mastermindspage (+ 14 43) "APL")
;; (find-mastermindspage (+ 14 59) "Forth")
;; (find-mastermindspage (+ 14 459) "Index")
;; (find-mastermindstext "")
;; ~/books/__comp/kernighan_ritchie__the_C_programming_language.tar.gz
;; ~/books/__comp/oreilly__essential_actionscript_2.0.chm
;; ~/books/__comp/oreilly__managing_projects_with_gnu_make.chm
;; ~/books/__comp/professional_software_devel.chm
;; ~/books/__comp/professional_software_devel.tar.gz
;; ~/books/__comp/salus__handbook_of_programming_languages_4.tgz
;; ~/books/__comp/gui_programming_with_Qt_4.chm
;; http://gigapedia.com/items/7127/programming-pearls
;; http://gigapedia.com/items/10108/programming-pearls--2nd-edition-
;; http://gigapedia.com/items/6460/more-programming-pearls--confessions-of-a-coder
;; http://gigapedia.com/items/265594/the-anatomy-of-programming-languages
(code-xpdf "tate7langs" "~/books/__comp/tate__seven_languages_in_seven_weeks.pdf")
(code-pdftotext "tate7langs" "~/books/__comp/tate__seven_languages_in_seven_weeks.pdf")
;; (find-tate7langspage 7 "Contents")
;; (find-tate7langspage 25 "2. Ruby")
;; (find-tate7langspage 60 "3. Io")
;; (find-tate7langspage 95 "4. Prolog")
;; (find-tate7langspage 135 "5. Scala")
;; (find-tate7langspage 181 "6. Erlang")
;; (find-tate7langspage 323 "Index")
;; (find-tate7langstext "")
;; Programming pearls 1, chap 13: "a spelling checker" - pipeline
;; (find-sh "grep gigapedia /tmp/pen/todo-persephone")
;; (find-sh "grep gigapedia /tmp/pen/notes-horses")
(code-xpdf "pliemilner" "~/books/__comp/plotkin_stirling_tofte__proof_language_and_interaction_essays_in_honor_of_robin_milner.pdf")
(code-pdftotext "pliemilner" "~/books/__comp/plotkin_stirling_tofte__proof_language_and_interaction_essays_in_honor_of_robin_milner.pdf")
;; (find-pliemilnerpage 6 "Contents")
;; (find-pliemilnerpage (+ 15 239) "Huet" "Saibi" "Constructive Category Theory")
;; (find-pliemilnertext "")
(code-djvu "kernighanpike" "~/books/__comp/kernighan_pike__the_unix_programming_environment.djvu")
(code-djvutotext "kernighanpike" "~/books/__comp/kernighan_pike__the_unix_programming_environment.djvu")
;; (find-kernighanpikepage 1 "Contents")
;; (find-kernighanpikepage (+ 1 1) "Index")
;; (find-kernighanpiketext "")
(code-xpdf "steele" "~/books/__comp/steele__common_lisp_the_language.pdf")
(code-pdftotext "steele" "~/books/__comp/steele__common_lisp_the_language.pdf")
;; (find-steelepage 2 "Contents")
;; (find-steelepage (+ 25 504) "19. Structures")
;; (find-steelepage (+ 25 1064) "Index")
;; (find-steeletext "")
(code-xpdf "seibel" "~/books/__comp/seibel__practical_common_lisp.pdf")
(code-pdftotext "seibel" "~/books/__comp/seibel__practical_common_lisp.pdf")
;; (find-seibelpage 7 "Contents at a glance")
;; (find-seibelpage 9 "Contents")
;; (find-seibelpage (+ 26 481) "Index")
;; (find-seibeltext "")
;; <icm2009>
;; (find-books "__comp/__comp.el" "icm2009")
;; https://link.springer.com/chapter/10.1007/978-3-642-02614-0_15
(code-pdf-page "icm2009" "~/books/__comp/intelligent_computer_mathematics_2009.pdf")
(code-pdf-text "icm2009" "~/books/__comp/intelligent_computer_mathematics_2009.pdf" 1)
;; (find-icm2009page)
;; (find-icm2009page 16 "Contents")
;; (find-icm2009page (+ 18 138) "Reasoning with Generic Cases" "in the Arithmetic of Abstract Matrices")
;; (find-icm2009text (+ 18 138) "Reasoning with Generic Cases" "in the Arithmetic of Abstract Matrices")
;; (find-icm2009page (+ 18 201) "Index")
;; (find-icm2009text "")
;; <almonen-sexton-sorge>
;; (find-books "__comp/__comp.el" "almonen-sexton-sorge")
;; https://sci-hub.tw/https://link.springer.com/article/10.1007/s10472-012-9299-5
(code-pdf-page "almonensextonsorge" "~/books/__comp/almomen_sexton_sorge__abstracting_symbolic_matrices.pdf")
(code-pdf-text "almonensextonsorge" "~/books/__comp/almomen_sexton_sorge__abstracting_symbolic_matrices.pdf" 1)
;; (find-almonensextonsorgepage)
;; (find-almonensextonsorgepage 1 "Contents")
;; (find-almonensextonsorgepage (+ 1 189) "Index")
;; (find-almonensextonsorgetext "")
;;
;; Local Variables:
;; mode: emacs-lisp
;; coding: utf-8-unix
;; End: