{"product_id":"write-great-code-volume-2-2nd-edition-isbn-9781718500389","title":"Write Great Code, Volume 2, 2nd Edition","description":"\u003cb\u003e\u003ci\u003eThinking Low-Level\u003c\/i\u003e, \u003ci\u003eWriting High-Level\u003c\/i\u003e, the second volume in the landmark \u003ci\u003eWrite Great Code\u003c\/i\u003e series by Randall Hyde, covers 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.\u003c\/b\u003e\u003cbr\u003e\u003cbr\u003eToday's programming languages offer productivity and portability, but also make it easy to write sloppy code that isn't optimized for a compiler. \u003ci\u003eThinking Low-Level, Writing High-Level \u003c\/i\u003ewill teach you to craft source code that results in good machine code once it's run through a compiler.\u003cbr\u003e\u003cbr\u003eYou'll learn:\u003cbr\u003e\u003cli\u003eHow to analyze the output of a compiler to verify that your code generates good machine code\u003c\/li\u003e\u003cli\u003eThe types of machine code statements that compilers generate for common control structures, so you can choose the best statements when writing HLL code\u003c\/li\u003e\u003cli\u003eEnough assembly language to read compiler output\u003c\/li\u003e\u003cli\u003eHow compilers convert various constant and variable objects into machine data\u003c\/li\u003e\u003cbr\u003eWith an understanding of how compilers work, you'll be able to write source code that they can translate into elegant machine code.\u003cbr\u003e\u003cbr\u003eNEW TO THIS EDITION, COVERAGE OF:\u003cbr\u003e\u003cli\u003eProgramming languages like Swift and Java\u003c\/li\u003e\u003cli\u003eCode generation on modern 64-bit CPUs\u003c\/li\u003e\u003cli\u003eARM processors on mobile phones and tablets\u003c\/li\u003e\u003cli\u003eStack-based architectures like the Java Virtual Machine\u003c\/li\u003e\u003cli\u003eModern language systems like the Microsoft Common Language Runtime\u003c\/li\u003e\u003cb\u003eIntroduction\u003c\/b\u003e\u003cbr\u003e\u003cbr\u003e\u003cb\u003eChapter 1: \u003c\/b\u003eThinking Low-Level, Writing High-Level\u003cbr\u003e\u003cb\u003eChapter 2:\u003c\/b\u003e Shouldn’t You Learn Assembly Language?\u003cbr\u003e\u003cb\u003eChapter 3:\u003c\/b\u003e 80x86 Assembly for the HLL Programmer\u003cbr\u003e\u003cb\u003eChapter 4:\u003c\/b\u003e Compiler Operation and Code Generation\u003cbr\u003e\u003cb\u003eChapter 5: \u003c\/b\u003eTools for Analyzing Compiler Output\u003cbr\u003e\u003cb\u003eChapter 6:\u003c\/b\u003e Constants and High-Level Languages\u003cbr\u003e\u003cb\u003eChapter 7:\u003c\/b\u003e Variables in a High-Level Language\u003cbr\u003e\u003cb\u003eChapter 8: \u003c\/b\u003eArray Data Types\u003cbr\u003e\u003cb\u003eChapter 9:\u003c\/b\u003e Pointer Data Types\u003cbr\u003e\u003cb\u003eChapter 10:\u003c\/b\u003e String Data Types\u003cbr\u003e\u003cb\u003eChapter 11:\u003c\/b\u003e Record, Union, and Class Data Types\u003cbr\u003e\u003cb\u003eChapter 12: \u003c\/b\u003eArithmetic and Logical Expressions\u003cbr\u003e\u003cb\u003eChapter 13:\u003c\/b\u003e Control Structures and Programmatic Decisions\u003cbr\u003e\u003cb\u003eChapter 14: \u003c\/b\u003eIterative Control Structures\u003cbr\u003e\u003cb\u003eChapter 15:\u003c\/b\u003e Functions and Procedures\u003cbr\u003e\u003cb\u003e\u003cbr\u003eAfterword: Engineering Software\u003cbr\u003eGlossary\u003c\/b\u003e\u003cb\u003ePraise for the first edition of \u003ci\u003eWrite Great Code, Volume 2:\u003c\/i\u003e\u003c\/b\u003e\u003cbr\u003e\u003cbr\u003e\"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.\" \u003cbr\u003e\u003cb\u003e—DevCity\u003c\/b\u003e \u003cbr\u003e\u003cbr\u003e\"\u003ci\u003eWrite Great Code Volume 2\u003c\/i\u003e 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. \u003cbr\u003e\u003cb\u003e—Free Software Magazine\u003c\/b\u003e \u003cbr\u003e\u003cbr\u003e\"As a high-level-language programmer, if you want to know what's really going on with your programs, you need to spend a little time learning assembly language—and you won't find an easier introduction.\" \u003cbr\u003e\u003cb\u003e—DevX\u003c\/b\u003e \u003cbr\u003e\u003cbr\u003e\"This is a good book. A very very good book. Frankly, I'm blown away at the quality of writing.\" \u003cbr\u003e\u003cb\u003e—Toronto Ruby User Group\u003c\/b\u003e\u003cb\u003eRandall Hyde\u003c\/b\u003e is the author of \u003ci\u003eThe Art of Assembly Language\u003c\/i\u003e, one of the most highly recommended resources on assembly, and the three volume \u003ci\u003eWrite Great Code\u003c\/i\u003e series (all No Starch Press). He is also the co-author of \u003ci\u003eThe Waite Group's MASM 6.0 Bible\u003c\/i\u003e. He has written for \u003ci\u003eDr. Dobb's Journal\u003c\/i\u003e and \u003ci\u003eByte\u003c\/i\u003e, as well as professional and academic journals.\u003cb\u003eINTRODUCTION\u003c\/b\u003e\u003cbr\u003e\u003cbr\u003eThere 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 don’t hear too many computer application users making such statements. \u003cbr\u003e\u003cbr\u003eAlthough 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, it’s 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. \u003cbr\u003e\u003cbr\u003eAlthough 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 application’s 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, Hoare’s comments were on the mark. The following excerpt from a short essay by Charles Cook (www.cookcomputing.com\/blog\/archives\/ 000084.html) describes the problem with reading too much into this statement: \u003cbr\u003e\u003cbr\u003e I’ve 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. \u003cbr\u003e\u003cbr\u003e 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. It’s usually not  worth spending a lot of time micro-optimizing code before it’s 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. \u003cbr\u003e\u003cbr\u003eHoare 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.\u003cbr\u003e\u003cbr\u003e Although you could certainly apply many of this book’s 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,” it’s unlikely they will ever find their way into your software. It’s just too much work to implement these ideas after the fact.\u003cbr\u003e\u003cbr\u003e 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. \u003cbr\u003e\u003cbr\u003eAn 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 today’s software engineers don’t know which of two implementations actually produces the more efficient code. \u003cbr\u003e\u003cbr\u003eThough you don’t need to be an expert assembly language programmer in order to write efficient code, if you’re going to study compiler output (as you will do in this book), you’ll need at least a reading knowledge of it. \u003cb\u003eChapters 3 and 4\u003c\/b\u003e provide a quick primer for 80x86 and PowerPC assembly language. \u003cbr\u003e\u003cbr\u003eIn \u003cb\u003eChapters 5 and 6\u003c\/b\u003e, you’ll 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. \u003cbr\u003e\u003cbr\u003eThe remainder of the book, \u003cb\u003eChapters 7 through 15\u003c\/b\u003e, 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. \u003cbr\u003e\u003cbr\u003eWhile you read, keep Dr. Hoare’s 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 project’s 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.","brand":"No Starch Press","offers":[{"title":"Default Title","offer_id":46303743705317,"sku":"NP9781718500389","price":49.95,"currency_code":"USD","in_stock":false}],"thumbnail_url":"\/\/cdn.shopify.com\/s\/files\/1\/1842\/7735\/files\/9781718500389.jpg?v=1767744601","url":"https:\/\/k12savings.com\/es\/products\/write-great-code-volume-2-2nd-edition-isbn-9781718500389","provider":"K12savings","version":"1.0","type":"link"}