Muutke küpsiste eelistusi

E-raamat: Essentials of Compilation: An Incremental Approach in Racket

4.33/5 (6 hinnangut Goodreads-ist)
  • Formaat: 240 pages
  • Sari: The MIT Press
  • Ilmumisaeg: 21-Feb-2023
  • Kirjastus: MIT Press
  • Keel: eng
  • ISBN-13: 9780262373289
Teised raamatud teemal:
  • Formaat - PDF+DRM
  • Hind: 104,00 €*
  • * hind on lõplik, st. muud allahindlused enam ei rakendu
  • Lisa ostukorvi
  • Lisa soovinimekirja
  • See e-raamat on mõeldud ainult isiklikuks kasutamiseks. E-raamatuid ei saa tagastada.
Essentials of Compilation: An Incremental Approach in RacketSuurem pilt
  • Formaat: 240 pages
  • Sari: The MIT Press
  • Ilmumisaeg: 21-Feb-2023
  • Kirjastus: MIT Press
  • Keel: eng
  • ISBN-13: 9780262373289
Teised raamatud teemal:

DRM piirangud

  • Kopeerimine (copy/paste):

    ei ole lubatud

  • Printimine:

    ei ole lubatud

  • Kasutamine:

    Digitaalõiguste kaitse (DRM)
    Kirjastus on väljastanud selle e-raamatu krüpteeritud kujul, mis tähendab, et selle lugemiseks peate installeerima spetsiaalse tarkvara. Samuti peate looma endale  Adobe ID Rohkem infot siin. E-raamatut saab lugeda 1 kasutaja ning alla laadida kuni 6'de seadmesse (kõik autoriseeritud sama Adobe ID-ga).

    Vajalik tarkvara
    Mobiilsetes seadmetes (telefon või tahvelarvuti) lugemiseks peate installeerima selle tasuta rakenduse: PocketBook Reader (iOS / Android)

    PC või Mac seadmes lugemiseks peate installima Adobe Digital Editionsi (Seeon tasuta rakendus spetsiaalselt e-raamatute lugemiseks. Seda ei tohi segamini ajada Adober Reader'iga, mis tõenäoliselt on juba teie arvutisse installeeritud )

    Seda e-raamatut ei saa lugeda Amazon Kindle's. 

"This book guides the reader on the journey of constructing their own compiler for the racket programming language. Along the way the reader learns the essential concepts, algorithms, and data structures that underlie modern compilers"--

A hands-on approach to understanding and building compilers.

Compilers are notoriously some of the most difficult programs to teach and understand. Most books about compilers dedicate one chapter to each progressive stage, a structure that hides how language features motivate design choices. By contrast, this innovative textbook provides an incremental approach that allows students to write every single line of code themselves. Essentials of Compilation guides the reader in constructing their own compiler for a small but powerful programming language, adding complex language features as the book progresses. Jeremy Siek explains the essential concepts, algorithms, and data structures that underlie modern compilers and lays the groundwork for future study of advanced topics. Already in wide use by students and professionals alike, this rigorous but accessible book invites readers to learn by doing. 

  • Deconstructs the challenge of compiler construction into bite-sized pieces
  • Enhances learning by connecting language features to compiler design choices
  • Develops understanding of how programs are mapped onto computer hardware
  • Learn-by-doing approach suitable for students and professionals
  • Proven in the classroom
  • Extensive ancillary resources include source code and solutions
Preface xi
1 Preliminaries
1(12)
1.1 Abstract Syntax Trees
1(2)
1.2 Grammars
3(1)
1.3 Pattern Matching
4(2)
1.4 Recursive Functions
6(1)
1.5 Interpreters
6(3)
1.6 Example Compiler: A Partial Evaluator
9(4)
2 Integers and Variables
13(22)
2.1 The Var Language
13(3)
2.2 The x86int Assembly Language
16(6)
2.3 Planning the Trip to x86
22(3)
2.4 Uniquify Variables
25(2)
2.5 Remove Complex Operands
27(1)
2.6 Explicate Control
28(2)
2.7 Select Instructions
30(1)
2.8 Assign Homes
31(1)
2.9 Patch Instructions
32(1)
2.10 Generate Prelude and Conclusion
33(1)
2.11 Challenge: Partial Evaluator for Lvar
33(2)
3 Register Allocation
35(22)
3.1 Registers and Calling Conventions
36(2)
3.2 Liveness Analysis
38(4)
3.3 Build the Interference Graph
42(2)
3.4 Graph Coloring via Sudoku
44(5)
3.5 Patch Instructions
49(1)
3.6 Prelude and Conclusion
50(2)
3.7 Challenge: Move Biasing
52(3)
3.8 Further Reading
55(2)
4 Booleans and Conditionals
57(26)
4.1 The Lif Language
58(1)
4.2 Type Checking Lif Programs
59(5)
4.3 The Ck Intermediate Language
64(1)
4.4 The x86k Language
64(2)
4.5 Shrink the Lif Language
66(1)
4.6 Uniquify Variables
67(1)
4.7 Remove Complex Operands
67(1)
4.8 Explicate Control
68(6)
4.9 Select Instructions
74(1)
4.10 Register Allocation
75(2)
4.11 Patch Instructions
77(1)
4.12 Challenge: Optimize Blocks and Remove Jumps
77(4)
4.13 Further Reading
81(2)
5 Loops and Dataflow Analysis
83(14)
5.1 The Lwhile Language
84(1)
5.2 Cyclic Control Flow and Dataflow Analysis
85(4)
5.3 Mutable Variables and Remove Complex Operands
89(2)
5.4 Uncover get!
91(1)
5.5 Remove Complex Operands
92(1)
5.6 Explicate Control and Co
93(1)
5.7 Select Instructions
94(1)
5.8 Register Allocation
95(2)
6 Tuples and Garbage Collection
97(30)
6.1 The LTup Language
97(3)
6.2 Garbage Collection
100(8)
6.3 Expose Allocation
108(1)
6.4 Remove Complex Operands
109(1)
6.5 Explicate Control and the dup Language
110(1)
6.6 Select Instructions and the x86Giobai Language
110(5)
6.7 Register Allocation
115(1)
6.8 Prelude and Conclusion
115(2)
6.9 Challenge: Simple Structures
117(2)
6.10 Challenge: Arrays
119(4)
6.11 Uncover get!
123(1)
6.12 Challenge: Generational Collection
124(1)
6.13 Further Reading
125(2)
7 Functions
127(18)
7.1 The LFun Language
127(5)
7.2 Functions in x86
132(3)
7.3 Shrink LFun
135(1)
7.4 Reveal Functions and the LFunRef Language
135(1)
7.5 Limit Functions
135(1)
7.6 Remove Complex Operands
136(1)
7.7 Explicate Control and the CFun Language
136(2)
7.8 Select Instructions and the x86 Def callq* Language
138(2)
7.9 Register Allocation
140(1)
7.10 Patch Instructions
141(1)
7.11 Prelude and Conclusion
141(2)
7.12 An Example Translation
143(2)
8 Lexically Scoped Functions
145(16)
8.1 The Lλ Language
147(3)
8.2 Assignment and Lexically Scoped Functions
150(1)
8.3 Assignment Conversion
150(2)
8.4 Closure Conversion
152(2)
8.5 An Example Translation
154(1)
8.6 Expose Allocation
155(1)
8.7 Explicate Control and Ccios
155(1)
8.8 Select Instructions
155(3)
8.9 Challenge: Optimize Closures
158(2)
8.10 Further Reading
160(1)
9 Dynamic Typing
161(18)
9.1 The LDyn Language
161(5)
9.2 Representation of Tagged Values
166(1)
9.3 The LAny Language
166(6)
9.4 Cast Insertion: Compiling LDyn to LAny
172(1)
9.5 Reveal Casts
173(1)
9.6 Remove Complex Operands
174(1)
9.7 Explicate Control and LAny
174(1)
9.8 Select Instructions
174(3)
9.9 Register Allocation for LAny
177(2)
10 Gradual Typing
179(20)
10.1 Type Checking L?
179(8)
10.2 Interpreting Lcast
187(1)
10.3 Cast Insertion
188(3)
10.4 Lower Casts
191(1)
10.5 Differentiate Proxies
192(2)
10.6 Reveal Casts
194(1)
10.7 Closure Conversion
195(1)
10.8 Select Instructions
195(1)
10.9 Further Reading
196(3)
11 Generics
199(12)
11.1 Compiling Generics
206(1)
11.2 Resolve Instantiation
207(1)
11.3 Erase Generic Types
207(4)
A Appendix
211(4)
A.1 Interpreters
211(1)
A.2 Utility Functions
211(1)
A.3 x86 Instruction Set Quick Reference
212(3)
References 215(8)
Index 223
Lisainfo e-raamatute kohta Lisainfo e-raamatute kohta
Püsilink: https://www.kriso.ee/db/97802623732892e.html
Märksõnad: