Write Great Code, Volume 2, 2nd Edition: Thinking Low-Level, Writing High-Level

Description: Write Great Code, Volume 2, 2nd Edition by Randall Hyde Fully updated 2nd edition, explaining how compilers translate high-level language source code into low-level machine code. FORMAT Paperback LANGUAGE English CONDITION Brand New Publisher Description 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.Todays programmers are tasked with writing optimal computer code to produce high performance systems, whether for machine learning, data science, or artificial intelligence. This second edition of the highly-regarded Thinking Low-Level, Writing High-Level (Volume 2 in the best-selling Write Great Code series) teaches readers how to produce better machine code by directing the actions of their chosen compiler.This second edition has been updated to cover high-level programming languages (such as Swift and Java) as well as code generation on 64-bit CPUsARM, the Java Virtual Machine, and the Microsoft Common Runtime. Author Biography Randall Hyde is the creator of the Lisa assembler for Apple II and developer of the High Level Assembly Language (HSA). He is the author of The Art of Assembly Language, one of the most highly recommended resources on assembly since 1996, and the Write Great Code series. He has written for Dr. Dobbs Journal, Byte, and the Association for Computing Machinerys Ubiquity magazine. Table of Contents IntroductionChapter 1: Thinking Low-Level, Writing High-LevelChapter 2: Shouldnt You Learn Assembly Language?Chapter 3: 80x86 Assembly for the HLL ProgrammerChapter 4: Compiler Operation and Code GenerationChapter 5: Tools for Analyzing Compiler OutputChapter 6: Constants and High-Level LanguagesChapter 7: Variables in a High-Level LanguageChapter 8: Array Data TypesChapter 9: Pointer Data TypesChapter 10: String Data TypesChapter 11: Record, Union, and Class Data TypesChapter 12: Arithmetic and Logical ExpressionsChapter 13: Control Structures and Programmatic DecisionsChapter 14: Iterative Control StructuresChapter 15: Functions and ProceduresAfterword: Engineering SoftwareGlossary Review Praise for the first edition of Write Great Code, Volume 2:"Set aside some money and buy this book, or get a friend to buy it and get it from them while still in the store. When you get home, read it TWICE so that you master what is in these pages. Then read it again." —DevCity "Write Great Code Volume 2 exceeds its goal of helping developers pay more attention to application performance when writing applications in high-level languages. This book is a must for any high-level application developer. —Free Software Magazine "As a high-level-language programmer, if you want to know whats really going on with your programs, you need to spend a little time learning assembly language—and you wont find an easier introduction." —DevX "This is a good book. A very very good book. Frankly, Im blown away at the quality of writing." —Toronto Ruby User Group Promotional 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. Review Quote Praise for the first edition of Write Great Code, Volume 2: "Set aside some money and buy this book, or get a friend to buy it and get it from them while still in the store. When you get home, read it TWICE so that you master what is in these pages. Then read it again." --DevCity " Write Great Code Volume 2 exceeds its goal of helping developers pay more attention to application performance when writing applications in high-level languages. This book is a must for any high-level application developer. --Free Software Magazine "As a high-level-language programmer, if you want to know whats really going on with your programs, you need to spend a little time learning assembly language--and you wont find an easier introduction." --DevX "This is a good book. A very very good book. Frankly, Im blown away at the quality of writing." --Toronto Ruby User Group Promotional "Headline" 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. Excerpt from Book INTRODUCTION There are many aspects of great code--far too many to describe properly in a single book. Therefore, this second volume of the Write Great Code series concentrates on one important part of great code: performance. As computer systems have increased in performance from MHz, to hundreds of MHz, to GHz, the performance of computer software has taken a back seat to other concerns. Today, it is not at all uncommon for software engineers to exclaim, "You should never optimize your code!" Funny, you dont hear too many computer application users making such statements. Although this book describes how to write efficient code, it is not a book about optimization. Optimization is a phase near the end of the software development cycle in which software engineers determine why their code does not meet performance specifications and then massage the code to achieve those specifications. But unfortunately, if no thought is put into the performance of the application until the optimization phase, its unlikely that optimization will prove practical. The time to ensure that an application has reasonable performance characteristics is at the beginning, during the design and implementation phases. Optimization can fine-tune the performance of a system, but it can rarely deliver a miracle. Although the quote is often attributed to Donald Knuth, who popularized it, it was Tony Hoare who originally said, "Premature optimization is the root of all evil." This statement has long been the rallying cry of software engineers who avoid any thought of application performance until the very end of the software-development cycle--at which point the optimization phase is typically ignored for economic or time-to-market reasons. However, Hoare did not say, "Concern about application performance during the early stages of an applications development is the root of all evil." He specifically said premature optimization, which, back then, meant counting cycles and instructions in assembly language code--not the type of coding you want to do during initial program design, when the code base is rather fluid. So, Hoares comments were on the mark. The following excerpt from a short essay by Charles Cook 000084.html) describes the problem with reading too much into this statement: Ive always thought this quote has all too often led software designers into serious mistakes because it has been applied to a different problem domain to what was intended. The full version of the quote is "We should forget about small efficiencies, say about 97% of the time: premature optimization is the root of all evil." and I agree with this. Its usually not worth spending a lot of time micro-optimizing code before its obvious where the performance bottlenecks are. But, conversely, when designing software at a system level, performance issues should always be considered from the beginning. A good software developer will do this automatically, having developed a feel for where performance issues will cause problems. An inexperienced developer will not bother, misguidedly believing that a bit of fine tuning at a later stage will fix any problems. Hoare was really saying that software engineers should worry about other issues, like good algorithm design and good implementations of those algorithms, before they worry about traditional optimizations, like how many CPU cycles a particular statement requires for execution. Although you could certainly apply many of this books concepts during an optimization phase, most of the techniques here really need to be done during initial coding. If you put them off until you reach "code complete," its unlikely they will ever find their way into your software. Its just too much work to implement these ideas after the fact. This book will teach you how to choose appropriate high-level language (HLL) statements that translate into efficient machine code with a modern optimizing compiler. With most HLLs, using different statements provides many ways to achieve a given result; and, at the machine level, some of these ways are naturally more efficient than others. Though there may be a very good reason for choosing a less-efficient statement sequence over a more efficient one (e.g., for readability purposes), the truth is that most software engineers have no idea about the runtime costs of HLL statements. Without such knowledge, they are unable to make an educated choice concerning statement selection. The goal of this book is to change that. An experienced software engineer may argue that the implementation of these individual techniques produces only minor improvements in performance. In some cases, this evaluation is correct; but we must keep in mind that these minor effects accumulate. While one can certainly abuse the techniques this book suggests, producing less readable and less maintainable code, it only makes sense that, when presented with two otherwise equivalent code sequences (from a system design point of view), you should choose the more efficient one. Unfortunately, many of todays software engineers dont know which of two implementations actually produces the more efficient code. Though you dont need to be an expert assembly language programmer in order to write efficient code, if youre going to study compiler output (as you will do in this book), youll need at least a reading knowledge of it. Chapters 3 and 4 provide a quick primer for 80x86 and PowerPC assembly language. In Chapters 5 and 6 , youll learn about determining the quality of your HLL statements by examining compiler output. These chapters describe disassemblers, object code dump tools, debuggers, various HLL compiler options for displaying assembly language code, and other useful software tools. The remainder of the book, Chapters 7 through 15 , describes how compilers generate machine code for different HLL statements and data types. Armed with this knowledge, you will be able to choose the most appropriate data types, constants, variables, and control structures to produce efficient applications. While you read, keep Dr. Hoares quote in mind: "Premature optimization is the root of all evil." It is certainly possible to misapply the information in this book and produce code that is difficult to read and maintain. This would be especially disastrous during the early stages of your projects design and implementation, when the code is fluid and subject to change. But remember: This book is not about choosing the most efficient statement sequence, regardless of the consequences; it is about understanding the cost of various HLL constructs so that, when you have a choice, you can make an educated decision concerning which sequence to use. Sometimes, there are legitimate reasons to choose a less efficient sequence. However, if you do not understand the cost of a given statement, there is no way for you to choose a more efficient alternative. Description for Sales People This 2nd edition has guidance on Swift and Java, 64-bit CPUsARM, Java Virtual Machine and the Microsoft Common Runtime. The Write Great Code series is a well-established series on core computer science topics. Hyde is the developer of the Lisa assembler for Apple II and the High Level Assembly Language. He has written extensively on the subject for over 20 years, and is a highly regarded expert in the field. A long-awaited volume in the series about Engineering Software is in the works. Details ISBN1718500386 Author Randall Hyde Year 2020 ISBN-10 1718500386 ISBN-13 9781718500389 Format Paperback Imprint No Starch Press,US Place of Publication San Francisco Country of Publication United States DEWEY 005.1 Short Title Write Great Code, Volume 2, 2nd Edition Language English Subtitle Thinking Low-Level, Writing High-Level Publication Date 2020-08-11 UK Release Date 2020-08-11 AU Release Date 2020-08-11 NZ Release Date 2020-08-11 US Release Date 2020-08-11 Narrator Jonathan Glover Illustrator Robin Rosenthal Birth 1939 Death 1988 Affiliation Associate Professor of Psychiatry, Bipolar Clinic and Reseach Program, Massachusetts General Hospital Position Associate Professor of Psychiatry Qualifications Ph.D. Publisher No Starch Press,US Audience General Pages 656 We've got this At The Nile, if you're looking for it, we've got it. With fast shipping, low prices, friendly service and well over a million items - you're bound to find what you want, at a price you'll love! TheNile_Item_ID:141763954;

Price: 83.21 AUD

Location: Melbourne

End Time: 2024-11-09T03:33:59.000Z

Shipping Cost: 0 AUD