BN.com Gift Guide

SPARC Architecture, Assembly Language Programming, and C / Edition 2

Paperback (Print)
Rent
Rent from BN.com
$41.58
(Save 75%)
Est. Return Date: 02/16/2015
Buy Used
Buy Used from BN.com
$98.23
Used and New from Other Sellers
Used and New from Other Sellers
from $39.47
Usually ships in 1-2 business days
(Save 76%)
Other sellers (Paperback)
  • All (17) from $39.47   
  • New (7) from $126.55   
  • Used (10) from $39.47   

Overview

Written from a programmer's perspective, this long-awaited revision introduces the SPARC assembly language to readers early on. Other introductory material encompasses making use of UNIX tools. Further coverage includes a formal definition of the von Neumann machine, its relationship to programmable calculators, and to the JAVA bytecode and JAVA virtual machine. For engineers, computer scientists, and people in business who want to learn about SPARC Architecture.

Read More Show Less

Editorial Reviews

Booknews
Introduces the SPARC assembly language from a programmer's perspective, and covers making use of UNIX tools, and the von Neumann machine and its relationship to programmable calculators and to the JAVA bytecode and JAVA virtual machine. Can be used by students in introductory computer architecture courses, and by those programming SPARC architecture machines in languages such as C and C++. This second edition offers more material on the new Ultra SPARC architecture, and on floating point, traps, and other architectures. The author teaches at the University of Pennsylvania in computer and information science. Annotation c. Book News, Inc., Portland, OR (booknews.com)
Read More Show Less

Product Details

  • ISBN-13: 9780130255969
  • Publisher: Prentice Hall
  • Publication date: 7/29/1999
  • Edition description: 2nd Edition
  • Edition number: 2
  • Pages: 528
  • Sales rank: 1,159,260
  • Product dimensions: 7.00 (w) x 9.13 (h) x 1.18 (d)

Meet the Author

RICHARD P. PAUL received a Ph.D. degree in Computer Science from Stanford University. His career as an educator and researcher has spanned three decades, beginning with his development of the WAVE robot language. He was one of the first researchers to demonstrate the use of programmable robots for assembly. He went on to join the faculty at Purdue University as a professor of Electrical Engineering and the Ransburg Professor of Robotics. Dr. Paul currently teaches at the University of Pennsylvania in Computer and Information Science. His expertise extends his contributions into major U.S. robot manufacturers, researching the field of robot programming language development. He has served as one of the founding editors of the International Journal of Robotics Research, as well as a President of the IEEE Council on Robotics and Automation. This year Dr. Paul will become emeritus. His current research and development interests include time-delayed teleoperation and the development of the teleprogramming system.

Read More Show Less

Read an Excerpt

Preface to the First Edition

This book is written as an introductory text in computer architecture for the SPARC reduced instruction set architecture. It is assumed that readers have a working knowledge of C and UNIX. The GNU compiler gcc and the gdb debugger are used.

Computer architecture is closely related to assembly language programming, as it is through assembly language programs that the architecture of a machine is made apparent. The presentation of the material breaks from the tradition of computer architecture texts in which assembly language programming was presented as a language in which one might write programs; with a knowledge of the computer architecture, there are, today, a number of high-level languages, such as C, which provide most of the capabilities of assembly language programming. The use of high-level languages results in much higher programmer efficiency and level of representation. It is, however, important to understand the machine at the assembly language level in order to write high-level programs intelligently: to decide between competing data and control structures, the use of global variables and function parameters, the use of recursion, nested procedures, etc. While many of these choices are influenced by high-level factors, the machine architecture has a profound effect on the computational efficiency of the resulting choice.

Although the machine language of a computer is easy to understand, its use results in vast quantities of numeric data that have little meaning. Related to the very heart of computer science is the use of symbol manipulation to simplify and to bring to a clear level of understanding the manipulation and generation of low-level numeric codes. Therefore, symbol manipulation is introduced in the first chapter in the form of the m4 macro processor. Throughout the remainder of the book macros are used to simplify and clarify what is being programmed. The generation of reams of assembly language code is discouraged in favor of the highest level of representation possible.

The computer is introduced by way of the calculator, as most students are familiar with calculators. We make use of the Hewlett-Packard programmable calculator, which reveals many details of machine architectures. The HP calculators have a natural machine language. Assembly language programming is introduced to generate calculator programs making use of m4. A more formal introduction to the machine is presented in the latter half of the first chapter. Stack, accumulator, and load/store machine architectures are also introduced in the first chapter.

The second chapter introduces the SPARC architecture so that students may start programming as early as possible. Like swimming, assembly language programming is not learned in a library! Making use of the machine registers for variable storage, students may start writing short programs by the end of the chapter. The assembler, as, is introduced along with gdb, the debugger. Formatted output is deferred until very late in the book to prevent students from developing the "insert a print statement" mode of program debugging. Instead, gdb is introduced as a natural way to examine memory and registers, and to execute programs. The assembler, as, lacks a macro expansion capability, as it was only designed to be an efficient final pass for the compiler, which has its own macro facilities. In general, we will use the assembler as a second pass to m4, which provides a macro facility. Branching is introduced in the second chapter, as it is difficult to write very interesting programs without branches. Together with branching, pipelining is introduced with the resulting need for delay slot instructions. As the initial specification of the SPARC architecture did not have a multiplication or division instruction, calls to the system routines .mul and .div, etc., are introduced in the second chapter without discussing what happens when the call is made.

As each of the architectural features of the machine is introduced it is related as closely as possible to C language constructs so that students learn the relationship between C and the resulting machine language structures. In the second chapter the control structures of C are introduced in assembly language form. In general, algorithms are written in C and then hand-coded into assembly language. Frequently, optimizations are then seen and the assembly language code optimized. However, we then return to C to learn how the optimized code might have been generated directly from C or why it could not. In this way students learn the problems that compiler writers must face and the reasons why many programs are written the way they are.

Once students are able to write and execute simple assembly language programs, binary logic and arithmetic are introduced. Chapter 3 introduces binary storage devices and number systems: binary, octal, and hexadecimal and their conversions. Bitwise logic operations are introduced and the use of the register %g0, which always yields a zero when used as a source register, effectively increasing the instruction set of the machine. Chapter 4 introduces modulus arithmetic and binary multiplication and division. The treatment of multiplication is fairly extensive, as it is needed to understand the multiply-step instruction of the SPARC architecture. Signed and unsigned comparisons are discussed. The chapter concludes with extended precision arithmetic.

Chapter 5 introduces the stack for the storage of variables. Frames are introduced to provide local storage for functions. The definition of variable offsets is discussed and problems of memory alignment and the load and store instructions. Macros are made use of in the definition of stack offsets and the adjustment of the stack pointer to provide storage. Variables are addressed relative to the frame pointer, which is natural for this architecture. We defer the use of static data until Chapter 9, as their use is clumsy with the SPARC architecture and is not representative of current programming practice.

Chapter 6 introduces multidimensional arrays and structures. Problems of array bound checking and lower bounds differing from zero are discussed along with the problems of dynamic arrays so that students understand the reasons for array addressing restrictions in C. Multiplication by constants for array subscripting is introduced and macros for the automatic generation of multiplication sequences developed in Appendix C. The simplicity of structure addressing is presented so that students understand that arrays, while conceptually simple, are usually a poor choice when structures may be used in their place. Macros are developed for the definition of structure fields and storage allocation.

Functions are then introduced, with discussion of the following: register sets, subroutine linkage, arguments, and return values. Examples are given of simple function calls and of function calls with many arguments or that return aggregates. Finally, leaf routines are presented with their limited register usage.

Chapter 8 introduces the machine language of the SPARC architecture and presents the concepts of instruction decoding and operand access. The handling of 32-bit constants is presented together with program counter relative addressing.

In Chapter 9, global data, initialized data, and addressing methods are discussed. ASCII strings are introduced and formatted output discussed. The switch C statement's translation into assembly language is introduced in this chapter. The handling of C command line arguments is presented along with linking with other code.

Chapter 10 discusses input/output from character devices up through I/O processors. The chapter concludes with a section on system input/output using traps.

It is not until Chapter 11 that floating-point is introduced. Floating-point may be left out of a course without affecting the other material. The concept of additional processors with multiple functional units is discussed as well as the interlocking of the floating-point processor with the integer unit. Single, double, and extended precision number formats are described along with NaN's (not a number) and subnormal numbers.

Chapter 12 discusses supervisor mode, processor state registers, and traps. Register window saving by means of traps is discussed in detail. Interrupts are introduced together with hardware traps. This chapter may also be left out of a course without detracting from the other material.

Chapter 13 introduces sharing of the processor between many users and the mechanisms for so doing. Sharing memory is of primary importance and the SPARC virtual memory mapping, translation lookaside buffer, and cache memory system are presented. The chapter concludes with a discussion of context switching.

Chapter 14 presents some alternative architectures, the PDP-11 for historical interest, the VAX as an example of a CISC machine, and the MIPS RISC machine as a contemporary architecture. This chapter may also be left out of a course without detracting from the other material.

Appendices include the macro definitions used in the book, the use of macros to generate an open subroutine for integer multiplication by constants, the user mode instruction set, a table of powers of 2, and the description of m4.

In an introductory course for students, Chapters 1 through 9 would logically be followed in order. Additional material could then be selected by the instructor: system I/O, floating-point, traps, virtual memory, other architectures; each of these chapters is independent and may be covered in any order.

For the professional reader, Chapter 2 provides an introduction, followed by the discussion of multiplication on the SPARC at the end of Chapter 4. This should then be followed by Chapters 5 through 13. The appendices provide all the necessary reference material for those interested in user mode programming. The text should be supplemented by the SPARC architecture manual for the professional programmer.

The book was produced by the Latex document preparation system 13 and postscript files were generated by Textures. Figures were drawn using the xfig program.

Mark Foster helped with gdb and the UNIX operating system and provided extensive proofreading corrections. Craig Sayers assisted with the interpretation of the architecture and with technical aspects of the presentation. Angela Lai corrected the Instruction Set Appendix. Doug Nelson provided almost instant responses to my many questions relating to Sun. Horst Hogenkamp assisted with a very careful proofreading and suggestions for clarifying the presentation. Carl Bredlau offered support and thoughtful comments, suggestions, and corrections. Rina Ramamurthy and John Turner assisted with careful reviews and comments. Mel Paul assisted with revisions and editorial changes. Raymond McKendall was extremely helpful with the formatting of the final version of the book. My thanks to all the above. I also wish to thank Tom McElwee, Bill Zobrist, and Jennifer Wenzel at Prentice Hall, who made publication of the book such a pleasant and straightforward matter. Appendix D, Appendix E, and Appendix H are printed with permission from Sun Microsystems, Inc.

Preface to the Second Edition

Since the first edition of the book Sun has announced both a superscalar version of the architecture and an increase in the memory address size from 32 bits to 64 - the Ultra SPARC. The architecture remains binary compatible with the original, which is discussed in detail in the book. A new chapter has been added to describe the new Ultra SPARC architecture, its additional instructions, its compatibility with the existing architecture, and changes to the supervisor mode.

A number of other changes have been made throughout the book to keep it current. The description of the Burroughs B5000, as an example of a stack architecture, has been replaced by a description of a version of the Java virtual machine to support the integer bytecode instructions together with a simulator written in C. New tools are provided for debugging double-precision programs. An extended discussion and example of tagged arithmetic has been added. New exercises have been included. The description of pipelining has been rewritten with a more detailed example. The example of division has been brought into line with the description of multiplication.

A number of people have helped with the preparation of the second edition. Raymond McKendall provided vital Latex support. Jorgen Wahlsten, Dave Reed, and Kostas Daniilidis helped with errors in the book. Joe Bissell provides corrections and pointed out that m4 now includes bitwise operators. Petra Recter, Barbara Till, and Alan Apt of Prentice Hall made the publication of the second edition as straightforward as the first. I also wish to thank reviewers Carl Bredlau and Peter Jones for their helpful insights. Alex Malex helped with Unix system problems and Sean Sheridan with the Web pages. Mel Paul helped with revisions and editorial changes.

Richard P. Paul

Availability of Software

Latest updates to the book may be obtained from the following Web site:

http://www.prenhall.com/paul

At this site you will also find all the software to accompany this text, macro definition files, and all example programs in the text. The example programs and files may be downloaded together or accessed individually from the Web. To obtain an instructors manual, which includes the originals for all figures and tables suitable for making slides and solutions to exercises, you should contact your Prentice Hall sales representative.

Read More Show Less

Table of Contents

1. The Computer.

2. SPARC Architecture.

3. Digital Logic and Binary Numbers.

4. Binary Arithmetic.

5. The Stack.

6. Data Structures.

7. Subroutines.

8. Machine Instructions.

9. External Data and Text.

10. Input/Output.

11. Floating-Point.

12. Traps and Exceptions.

13. Memory Management.

14. Other Architectures.

15. Ultra Sparc.

Appendix A: Macro Definitions.

Appendix B: Multiplication by Constants.

Appendix C: User Mode Machine Instructions.

Appendix D: Synthetic Instructions and Pseudo-Ops.

Appendix E: Instructions Sorted Alphabetically.

Appendix F: Powers of 2.

Appendix G: Macro Language Processor m4.

Index.

Read More Show Less

Preface

Preface to the First Edition

This book is written as an introductory text in computer architecture for the SPARC reduced instruction set architecture. It is assumed that readers have a working knowledge of C and UNIX. The GNU compiler gcc and the gdb debugger are used.

Computer architecture is closely related to assembly language programming, as it is through assembly language programs that the architecture of a machine is made apparent. The presentation of the material breaks from the tradition of computer architecture texts in which assembly language programming was presented as a language in which one might write programs; with a knowledge of the computer architecture, there are, today, a number of high-level languages, such as C, which provide most of the capabilities of assembly language programming. The use of high-level languages results in much higher programmer efficiency and level of representation. It is, however, important to understand the machine at the assembly language level in order to write high-level programs intelligently: to decide between competing data and control structures, the use of global variables and function parameters, the use of recursion, nested procedures, etc. While many of these choices are influenced by high-level factors, the machine architecture has a profound effect on the computational efficiency of the resulting choice.

Although the machine language of a computer is easy to understand, its use results in vast quantities of numeric data that have little meaning. Related to the very heart of computer science is the use of symbol manipulation to simplify and to bring to a clear level of understanding the manipulation and generation of low-level numeric codes. Therefore, symbol manipulation is introduced in the first chapter in the form of the m4 macro processor. Throughout the remainder of the book macros are used to simplify and clarify what is being programmed. The generation of reams of assembly language code is discouraged in favor of the highest level of representation possible.

The computer is introduced by way of the calculator, as most students are familiar with calculators. We make use of the Hewlett-Packard programmable calculator, which reveals many details of machine architectures. The HP calculators have a natural machine language. Assembly language programming is introduced to generate calculator programs making use of m4. A more formal introduction to the machine is presented in the latter half of the first chapter. Stack, accumulator, and load/store machine architectures are also introduced in the first chapter.

The second chapter introduces the SPARC architecture so that students may start programming as early as possible. Like swimming, assembly language programming is not learned in a library! Making use of the machine registers for variable storage, students may start writing short programs by the end of the chapter. The assembler, as, is introduced along with gdb, the debugger. Formatted output is deferred until very late in the book to prevent students from developing the "insert a print statement" mode of program debugging. Instead, gdb is introduced as a natural way to examine memory and registers, and to execute programs. The assembler, as, lacks a macro expansion capability, as it was only designed to be an efficient final pass for the compiler, which has its own macro facilities. In general, we will use the assembler as a second pass to m4, which provides a macro facility. Branching is introduced in the second chapter, as it is difficult to write very interesting programs without branches. Together with branching, pipelining is introduced with the resulting need for delay slot instructions. As the initial specification of the SPARC architecture did not have a multiplication or division instruction, calls to the system routines .mul and .div, etc., are introduced in the second chapter without discussing what happens when the call is made.

As each of the architectural features of the machine is introduced it is related as closely as possible to C language constructs so that students learn the relationship between C and the resulting machine language structures. In the second chapter the control structures of C are introduced in assembly language form. In general, algorithms are written in C and then hand-coded into assembly language. Frequently, optimizations are then seen and the assembly language code optimized. However, we then return to C to learn how the optimized code might have been generated directly from C or why it could not. In this way students learn the problems that compiler writers must face and the reasons why many programs are written the way they are.

Once students are able to write and execute simple assembly language programs, binary logic and arithmetic are introduced. Chapter 3 introduces binary storage devices and number systems: binary, octal, and hexadecimal and their conversions. Bitwise logic operations are introduced and the use of the register %g0, which always yields a zero when used as a source register, effectively increasing the instruction set of the machine. Chapter 4 introduces modulus arithmetic and binary multiplication and division. The treatment of multiplication is fairly extensive, as it is needed to understand the multiply-step instruction of the SPARC architecture. Signed and unsigned comparisons are discussed. The chapter concludes with extended precision arithmetic.

Chapter 5 introduces the stack for the storage of variables. Frames are introduced to provide local storage for functions. The definition of variable offsets is discussed and problems of memory alignment and the load and store instructions. Macros are made use of in the definition of stack offsets and the adjustment of the stack pointer to provide storage. Variables are addressed relative to the frame pointer, which is natural for this architecture. We defer the use of static data until Chapter 9, as their use is clumsy with the SPARC architecture and is not representative of current programming practice.

Chapter 6 introduces multidimensional arrays and structures. Problems of array bound checking and lower bounds differing from zero are discussed along with the problems of dynamic arrays so that students understand the reasons for array addressing restrictions in C. Multiplication by constants for array subscripting is introduced and macros for the automatic generation of multiplication sequences developed in Appendix C. The simplicity of structure addressing is presented so that students understand that arrays, while conceptually simple, are usually a poor choice when structures may be used in their place. Macros are developed for the definition of structure fields and storage allocation.

Functions are then introduced, with discussion of the following: register sets, subroutine linkage, arguments, and return values. Examples are given of simple function calls and of function calls with many arguments or that return aggregates. Finally, leaf routines are presented with their limited register usage.

Chapter 8 introduces the machine language of the SPARC architecture and presents the concepts of instruction decoding and operand access. The handling of 32-bit constants is presented together with program counter relative addressing.

In Chapter 9, global data, initialized data, and addressing methods are discussed. ASCII strings are introduced and formatted output discussed. The switch C statement's translation into assembly language is introduced in this chapter. The handling of C command line arguments is presented along with linking with other code.

Chapter 10 discusses input/output from character devices up through I/O processors. The chapter concludes with a section on system input/output using traps.

It is not until Chapter 11 that floating-point is introduced. Floating-point may be left out of a course without affecting the other material. The concept of additional processors with multiple functional units is discussed as well as the interlocking of the floating-point processor with the integer unit. Single, double, and extended precision number formats are described along with NaN's not a number and subnormal numbers.

Chapter 12 discusses supervisor mode, processor state registers, and traps. Register window saving by means of traps is discussed in detail. Interrupts are introduced together with hardware traps. This chapter may also be left out of a course without detracting from the other material.

Chapter 13 introduces sharing of the processor between many users and the mechanisms for so doing. Sharing memory is of primary importance and the SPARC virtual memory mapping, translation lookaside buffer, and cache memory system are presented. The chapter concludes with a discussion of context switching.

Chapter 14 presents some alternative architectures, the PDP-11 for historical interest, the VAX as an example of a CISC machine, and the MIPS RISC machine as a contemporary architecture. This chapter may also be left out of a course without detracting from the other material.

Appendices include the macro definitions used in the book, the use of macros to generate an open subroutine for integer multiplication by constants, the user mode instruction set, a table of powers of 2, and the description of m4.

In an introductory course for students, Chapters 1 through 9 would logically be followed in order. Additional material could then be selected by the instructor: system I/O, floating-point, traps, virtual memory, other architectures; each of these chapters is independent and may be covered in any order.

For the professional reader, Chapter 2 provides an introduction, followed by the discussion of multiplication on the SPARC at the end of Chapter 4. This should then be followed by Chapters 5 through 13. The appendices provide all the necessary reference material for those interested in user mode programming. The text should be supplemented by the SPARC architecture manual for the professional programmer.

The book was produced by the Latex document preparation system 13 and postscript files were generated by Textures. Figures were drawn using the xfig program.

Mark Foster helped with gdb and the UNIX operating system and provided extensive proofreading corrections. Craig Sayers assisted with the interpretation of the architecture and with technical aspects of the presentation. Angela Lai corrected the Instruction Set Appendix. Doug Nelson provided almost instant responses to my many questions relating to Sun. Horst Hogenkamp assisted with a very careful proofreading and suggestions for clarifying the presentation. Carl Bredlau offered support and thoughtful comments, suggestions, and corrections. Rina Ramamurthy and John Turner assisted with careful reviews and comments. Mel Paul assisted with revisions and editorial changes. Raymond McKendall was extremely helpful with the formatting of the final version of the book. My thanks to all the above. I also wish to thank Tom McElwee, Bill Zobrist, and Jennifer Wenzel at Prentice Hall, who made publication of the book such a pleasant and straightforward matter. Appendix D, Appendix E, and Appendix H are printed with permission from Sun Microsystems, Inc.

Preface to the Second Edition

Since the first edition of the book Sun has announced both a superscalar version of the architecture and an increase in the memory address size from 32 bits to 64 - the Ultra SPARC. The architecture remains binary compatible with the original, which is discussed in detail in the book. A new chapter has been added to describe the new Ultra SPARC architecture, its additional instructions, its compatibility with the existing architecture, and changes to the supervisor mode.

A number of other changes have been made throughout the book to keep it current. The description of the Burroughs B5000, as an example of a stack architecture, has been replaced by a description of a version of the Java virtual machine to support the integer bytecode instructions together with a simulator written in C. New tools are provided for debugging double-precision programs. An extended discussion and example of tagged arithmetic has been added. New exercises have been included. The description of pipelining has been rewritten with a more detailed example. The example of division has been brought into line with the description of multiplication.

A number of people have helped with the preparation of the second edition. Raymond McKendall provided vital Latex support. Jorgen Wahlsten, Dave Reed, and Kostas Daniilidis helped with errors in the book. Joe Bissell provides corrections and pointed out that m4 now includes bitwise operators. Petra Recter, Barbara Till, and Alan Apt of Prentice Hall made the publication of the second edition as straightforward as the first. I also wish to thank reviewers Carl Bredlau and Peter Jones for their helpful insights. Alex Malex helped with Unix system problems and Sean Sheridan with the Web pages. Mel Paul helped with revisions and editorial changes.

Richard P. Paul

Availability of Software

Latest updates to the book may be obtained from the following Web site:

http://www.prenhall.com/paul

At this site you will also find all the software to accompany this text, macro definition files, and all example programs in the text. The example programs and files may be downloaded together or accessed individually from the Web. To obtain an instructors manual, which includes the originals for all figures and tables suitable for making slides and solutions to exercises, you should contact your Prentice Hall sales representative.

Read More Show Less

Customer Reviews

Average Rating 5
( 1 )
Rating Distribution

5 Star

(1)

4 Star

(0)

3 Star

(0)

2 Star

(0)

1 Star

(0)

Your Rating:

Your Name: Create a Pen Name or

Barnes & Noble.com Review Rules

Our reader reviews allow you to share your comments on titles you liked, or didn't, with others. By submitting an online review, you are representing to Barnes & Noble.com that all information contained in your review is original and accurate in all respects, and that the submission of such content by you and the posting of such content by Barnes & Noble.com does not and will not violate the rights of any third party. Please follow the rules below to help ensure that your review can be posted.

Reviews by Our Customers Under the Age of 13

We highly value and respect everyone's opinion concerning the titles we offer. However, we cannot allow persons under the age of 13 to have accounts at BN.com or to post customer reviews. Please see our Terms of Use for more details.

What to exclude from your review:

Please do not write about reviews, commentary, or information posted on the product page. If you see any errors in the information on the product page, please send us an email.

Reviews should not contain any of the following:

  • - HTML tags, profanity, obscenities, vulgarities, or comments that defame anyone
  • - Time-sensitive information such as tour dates, signings, lectures, etc.
  • - Single-word reviews. Other people will read your review to discover why you liked or didn't like the title. Be descriptive.
  • - Comments focusing on the author or that may ruin the ending for others
  • - Phone numbers, addresses, URLs
  • - Pricing and availability information or alternative ordering information
  • - Advertisements or commercial solicitation

Reminder:

  • - By submitting a review, you grant to Barnes & Noble.com and its sublicensees the royalty-free, perpetual, irrevocable right and license to use the review in accordance with the Barnes & Noble.com Terms of Use.
  • - Barnes & Noble.com reserves the right not to post any review -- particularly those that do not follow the terms and conditions of these Rules. Barnes & Noble.com also reserves the right to remove any review at any time without notice.
  • - See Terms of Use for other conditions and disclaimers.
Search for Products You'd Like to Recommend

Recommend other products that relate to your review. Just search for them below and share!

Create a Pen Name

Your Pen Name is your unique identity on BN.com. It will appear on the reviews you write and other website activities. Your Pen Name cannot be edited, changed or deleted once submitted.

 
Your Pen Name can be any combination of alphanumeric characters (plus - and _), and must be at least two characters long.

Continue Anonymously
Sort by: Showing 1 Customer Reviews
  • Posted September 7, 2010

    ***PRIME!!!

    Ever see a movie and when it ends your like "W-T-F"?!?!? I've had similiar experiences with books C/C++ programming until I picked this one up at Georgia State University Bookstore in Atlanta! FINALLY, I'm not left with near vague explanations as to why or how source files are mapped to *.o files... Richard Paul deciphers this layer of abstration left unexplained in MANY texts... As if some "magic" ocuurs during the the compilation stage... Thanks Richy Richh!!! A definate missing link!!!

    Was this review helpful? Yes  No   Report this review
Sort by: Showing 1 Customer Reviews

If you find inappropriate content, please report it to Barnes & Noble
Why is this product inappropriate?
Comments (optional)