Write Great Code Volume 2 thinking low level writing high level 1st Edition by Randall Hyde 9781593270032 1593270038

Write Great Code Volume 2 thinking low level writing high level 1st Edition by Randall Hyde  – Ebook PDF Instant Download/Delivery:9781593270032, 1593270038 
Full download Write Great Code Volume 2 thinking low level writing high level 1st Edition  after payment

Product details:

ISBN 10: 1593270038
ISBN 13: 9781593270032 
Author: Randall Hyde

Explains how compilers translate high-level language source code (like code written in Python) into low-level machine code (code that the computer can understand) to help readers understand how to produce the best low-level, computer readable machine code. In the beginning, most software was written in assembly, the CPU’s low-level language, in order to achieve acceptable performance on relatively slow hardware. Early programmers were sparing in their use of high-level language code, knowing that a high-level language compiler would generate crummy, low-level machine code for their software. Today, however, many programmers write in high-level languages like Python, C/C++/C#, Java, Swift. The result is often sloppy, inefficient code. But you don’t need to give up the productivity and portability of high-level languages in order to produce more efficient software. In this second volume of the Write Great Code series, you’ll learn:   •  How to analyze the output of a compiler to verify that your code does, indeed, generate good machine code   •  The types of machine code statements that compilers typically generate for common control structures, so you can choose the best statements when writing HLL code   •  Just enough 80×86 and PowerPC assembly language to read compiler output   •  How compilers convert various constant and variable objects into machine data, and how to use these objects to write faster and shorter programs NEW TO THIS EDITION, COVERAGE OF:   •  Programming languages like Swift and Java   •  Code generation on modern 64-bit CPUs   •  ARM processors on mobile phones and tablets   •  Stack-based architectures like the Java Virtual Machine   •  Modern language systems like the Microsoft Common Language Runtime With an understanding of how compilers work, you’ll be able to write source code that they can translate into elegant machine code. That understanding starts right here, with Write Great Code, Volume 2: Thinking Low-Level, Writing High-Level.

Write Great Code Volume 2 thinking low level writing high level 1st Table of contents:

1. THINKING LOW-LEVEL, WRITING HIGH-LEVEL

• 1.1 Misconceptions About Compiler Quality
• 1.2 Why Learning Assembly Language Is Still a Good Idea
• 1.3 Why Learning Assembly Language Isn’t Absolutely Necessary
• 1.4 Thinking Low-Level
• 1.5 Writing High-Level
• 1.6 Language-Neutral Approach
• 1.7 Additional Tips
• 1.8 For More Information

2. SHOULDN’T YOU LEARN ASSEMBLY LANGUAGE?

• 2.1 Benefits and Roadblocks to Learning Assembly Language
• 2.2 How This Book Can Help
• 2.3 High-Level Assemblers to the Rescue
• 2.4 High-Level Assembly Language
• 2.5 Thinking High-Level, Writing Low-Level
• 2.6 The Assembly Programming Paradigm (Thinking Low-Level)
• 2.7 For More Information

3. 80X86 ASSEMBLY FOR THE HLL PROGRAMMER

• 3.1 Learning One Assembly Language Is Good, Learning More Is Better
• 3.2 80×86 Assembly Syntaxes
• 3.3 Literal Constants
• 3.4 Manifest (Symbolic) Constants in Assembly Language
• 3.5 80×86 Addressing Modes
• 3.6 Declaring Data in Assembly Language
• 3.7 Specifying Operand Sizes in Assembly Language
• 3.8 For More Information

4. COMPILER OPERATION AND CODE GENERATION

• 4.1 File Types That Programming Languages Use
• 4.2 Source Files
• 4.3 Types of Computer Language Processors
• 4.4 The Translation Process
• 4.5 Compiler Output
• 4.6 Object File Formats
• 4.7 Executable File Formats
• 4.8 Data and Code Alignment in an Object File
• 4.9 How Linkers Affect Code
• 4.10 For More Information

5. TOOLS FOR ANALYZING COMPILER OUTPUT

• 5.1 Background
• 5.2 Telling a Compiler to Produce Assembly Output
• 5.3 Using Object Code Utilities to Analyze Compiler Output
• 5.4 Using a Disassembler to Analyze Compiler Output
• 5.5 Using the Java Bytecode Disassembler to Analyze Java Output
• 5.6 Using the IL Disassembler to Analyze Microsoft C# and Visual Basic Output
• 5.7 Using a Debugger to Analyze Compiler Output
• 5.8 Comparing Output from Two Compilations
• 5.9 For More Information

6. CONSTANTS AND HIGH-LEVEL LANGUAGES

• 6.1 Literal Constants and Program Efficiency
• 6.2 Binding Times
• 6.3 Literal Constants vs. Manifest Constants
• 6.4 Constant Expressions
• 6.5 Manifest Constants vs. Read-Only Memory Objects
• 6.6 Swift let Statements
• 6.7 Enumerated Types
• 6.8 Boolean Constants
• 6.9 Floating-Point Constants
• 6.10 String Constants
• 6.11 Composite Data Type Constants
• 6.12 Constants Don’t Change
• 6.13 For More Information

7. VARIABLES IN A HIGH-LEVEL LANGUAGE

• 7.1 Runtime Memory Organization
• 7.2 What Is a Variable?
• 7.3 Variable Storage
• 7.4 Common Primitive Data Types
• 7.5 Variable Addresses and High-Level Languages
• 7.6 Variable Alignment in Memory
• 7.7 For More Information

8. ARRAY DATA TYPES

• 8.1 Arrays
• 8.2 For More Information

9. POINTER DATA TYPES

• 9.1 The Definition of a Pointer
• 9.2 Pointer Implementation in High-Level Languages
• 9.3 Pointers and Dynamic Memory Allocation
• 9.4 Pointer Operations and Pointer Arithmetic
• 9.5 A Simple Memory Allocator Example
• 9.6 Garbage Collection
• 9.7 The OS and Memory Allocation
• 9.8 Heap Memory Overhead
• 9.9 Common Pointer Problems
• 9.10 Pointers in Modern Languages
• 9.11 Managed Pointers
• 9.12 For More Information

10. STRING DATA TYPES

• 10.1 Character String Formats
• 10.2 Static, Pseudo-Dynamic, and Dynamic Strings
• 10.3 Reference Counting for Strings
• 10.4 Delphi Strings
• 10.5 Using Strings in a High-Level Language
• 10.6 Unicode Character Data in Strings
• 10.7 Unicode String Functions and Performance
• 10.8 For More Information

11. RECORD, UNION, AND CLASS DATA TYPES

• 11.1 Records
• 11.2 Discriminant Unions
• 11.3 Variant Types
• 11.4 Namespaces
• 11.5 Classes and Objects
• 11.6 Protocols and Interfaces
• 11.7 Classes, Objects, and Performance
• 11.8 For More Information

12. ARITHMETIC AND LOGICAL EXPRESSIONS

• 12.1 Arithmetic Expressions and Computer Architecture
• 12.2 Optimization of Arithmetic Statements
• 12.3 Side Effects in Arithmetic Expressions
• 12.4 Containing Side Effects: Sequence Points
• 12.5 Avoiding Problems Caused by Side Effects
• 12.6 Forcing a Particular Order of Evaluation
• 12.7 Short-Circuit Evaluation
• 12.8 The Relative Cost of Arithmetic Operations
• 12.9 For More Information

13. CONTROL STRUCTURES AND PROGRAMMATIC DECISIONS

• 13.1 How Control Structures Affect a Program’s Efficiency
• 13.2 Introduction to Low-Level Control Structures
• 13.3 The goto Statement
• 13.4 The if Statement
• 13.5 The switch/case Statement
• 13.6 For More Information

14. ITERATIVE CONTROL STRUCTURES

• 14.1 The while Loop
• 14.2 The repeat..until (do..until/do..while) Loop
• 14.3 The forever..endfor Loop
• 14.4 The Definite Loop (for Loops)
• 14.5 For More Information

15. FUNCTIONS AND PROCEDURES

• 15.1 Simple Function and Procedure Calls
• 15.2 Leaf Functions and Procedures
• 15.3 Macros and Inline Functions
• 15.4 Passing Parameters to a Function or Procedure
• 15.5 Activation Records and the Stack
• 15.6 Parameter-Passing Mechanisms
• 15.7 Function Return Values
• 15.8 For More Information

People also search for Write Great Code Volume 2 thinking low level writing high level 1st:

write great code volume 2 2nd edition pdf
    
write great code volume 2 2nd edition
    
write great code volume 1 2nd edition understanding the machine
    
write great code volume 1 2nd edition pdf

Tags:

Randall Hyde,Write Great,Code