國立虎尾科技大學 |

Learn to Program with Assembly = Foundational Learning for New Programmers /

紀錄類型:	書目-語言資料,印刷品 : Monograph/item
正題名/作者:	Learn to Program with Assembly/ by Jonathan Bartlett.
其他題名:	Foundational Learning for New Programmers /
作者:	Bartlett, Jonathan.
面頁冊數:	XVII, 328 p. 11 illus.online resource. :
Contained By:	Springer Nature eBook
標題:	Programming languages (Electronic computers). -
電子資源:	https://doi.org/10.1007/978-1-4842-7437-8
ISBN:	9781484274378

Learn to Program with Assembly = Foundational Learning for New Programmers /
Bartlett, Jonathan.

Learn to Program with AssemblyFoundational Learning for New Programmers /[electronic resource] :by Jonathan Bartlett. - 1st ed. 2021. - XVII, 328 p. 11 illus.online resource.

Chapter 1: Introduction -- Chapter 2: The Truth About Computers -- Part I: Assembly Language Basics -- Chapter 3: Your First Program -- Chapter 4: Registers and Simple Arithmetic -- Chapter 5: Comparison, Branching and Looping -- Chapter 6: Working with Data in Memory -- Chapter 7: Data Records -- Chapter 8: Signed Numbers and Bitwise Operations -- Chapter 9: More Instructions You Should Know -- Part II: Operating System Basics -- Chapter 10: Making System Calls -- Chapter 11: The Stack and Function Calls -- Chapter 12: Calling Functions from Libraries -- Chapter 13: Common and Useful Assembler Directives -- Chapter 14: Dynamic Memory Allocation -- Chapter 15: Dynamic Linking -- Part III: Programming Language Topics -- Chapter 16: Basic Language Features Represented in Assembly Language -- Chapter 17: Tracking Memory Allocations -- Chapter 18: Object-Oriented Programming -- Chapter 19: Conclusion and Acknowledgments -- Part IV: Appendices -- Appendix A: Getting Set Up with Docker -- Appendix B: The Command Line -- Appendix C: Debugging with GDB -- Appendix D: Nasm (Intel) Assembly Language Syntax -- Appendix E: Common x86-64 Instructions -- Appendix F: Floating Point Numbers -- Appendix G: The Starting State of the Stack -- Appendix H: ASCII, Unicode, and UTF-8 -- Appendix I: Optimization -- Appendix J: A Simplified Garbage Collector -- Appendix K: Going to an Even Lower Level.

Many programmers have limited effectiveness because they don't have a deep understanding of how their computer actually works under the hood. In Learn to Program with Assembly, you will learn to program in assembly language - the language of the computer itself. Assembly language is often thought of as a difficult and arcane subject. However, author Jonathan Bartlett presents the material in a way that works just as well for first-time programmers as for long-time professionals. Whether this is your first programming book ever or you are a professional wanting to deepen your understanding of the computer you are working with, this book is for you. The book teaches 64-bit x86 assembly language running on the Linux operating system. However, even if you are not running Linux, a provided Docker image will allow you to use a Mac or Windows computer as well. The book starts with extremely simple programs to help you get your grounding, going steadily deeper with each chapter. At the end of the first section, you will be familiar with most of the basic instructions available on the processor that you will need for any task. The second part deals with interactions with the operating system. It shows how to make calls to the standard library, how to make direct system calls to the kernel, how to write your own library code, and how to work with memory. The third part shows how modern programming language features such as exception handling, object-oriented programming, and garbage collection work at the assembly language level. Additionally, the book comes with several appendices covering various topics such as running the debugger, vector processing, optimization principles, a list of common instructions, and other important subjects. This book is the 64-bit successor to Jonathan Bartlett's previous book, Programming from the Ground Up, which has been a programming classic for more than 15 years. This book covers similar ground but with modern 64-bit processors, and also includes a lot more information about how high level programming language features are implemented in assembly language. What You Will Learn How the processor operates How computers represent data internally How programs interact with the operating system How to write and use dynamic code libraries How high-level programming languages implement their features.

ISBN: 9781484274378

Standard No.: 10.1007/978-1-4842-7437-8doiSubjects--Topical Terms:

1127615
Programming languages (Electronic computers).

LC Class. No.: QA76.7-.73

Dewey Class. No.: 005.13

Learn to Program with Assembly = Foundational Learning for New Programmers /
LDR:05076nam a22003855i 4500 001 1059798
003 DE-He213
005 20220124160537.0
007 cr nn 008mamaa
008 220414s2021 xxu| s |||| 0|eng d
020 $a 9781484274378 $9 978-1-4842-7437-8
024 7 $a 10.1007/978-1-4842-7437-8 $2 doi
035 $a 978-1-4842-7437-8
050 4 $a QA76.7-.73
072 7 $a UMX $2 bicssc
072 7 $a COM000000 $2 bisacsh
072 7 $a UMX $2 thema
082 0 4 $a 005.13 $2 23
100 1 $a Bartlett, Jonathan. $e author. $4 aut $4 http://id.loc.gov/vocabulary/relators/aut $3 1308352
245 1 0 $a Learn to Program with Assembly $h [electronic resource] : $b Foundational Learning for New Programmers / $c by Jonathan Bartlett.
250 $a 1st ed. 2021.
264 1 $a Berkeley, CA : $b Apress : $b Imprint: Apress, $c 2021.
300 $a XVII, 328 p. 11 illus. $b online resource.
336 $a text $b txt $2 rdacontent
337 $a computer $b c $2 rdamedia
338 $a online resource $b cr $2 rdacarrier
347 $a text file $b PDF $2 rda
505 0 $a Chapter 1: Introduction -- Chapter 2: The Truth About Computers -- Part I: Assembly Language Basics -- Chapter 3: Your First Program -- Chapter 4: Registers and Simple Arithmetic -- Chapter 5: Comparison, Branching and Looping -- Chapter 6: Working with Data in Memory -- Chapter 7: Data Records -- Chapter 8: Signed Numbers and Bitwise Operations -- Chapter 9: More Instructions You Should Know -- Part II: Operating System Basics -- Chapter 10: Making System Calls -- Chapter 11: The Stack and Function Calls -- Chapter 12: Calling Functions from Libraries -- Chapter 13: Common and Useful Assembler Directives -- Chapter 14: Dynamic Memory Allocation -- Chapter 15: Dynamic Linking -- Part III: Programming Language Topics -- Chapter 16: Basic Language Features Represented in Assembly Language -- Chapter 17: Tracking Memory Allocations -- Chapter 18: Object-Oriented Programming -- Chapter 19: Conclusion and Acknowledgments -- Part IV: Appendices -- Appendix A: Getting Set Up with Docker -- Appendix B: The Command Line -- Appendix C: Debugging with GDB -- Appendix D: Nasm (Intel) Assembly Language Syntax -- Appendix E: Common x86-64 Instructions -- Appendix F: Floating Point Numbers -- Appendix G: The Starting State of the Stack -- Appendix H: ASCII, Unicode, and UTF-8 -- Appendix I: Optimization -- Appendix J: A Simplified Garbage Collector -- Appendix K: Going to an Even Lower Level.
520 $a Many programmers have limited effectiveness because they don't have a deep understanding of how their computer actually works under the hood. In Learn to Program with Assembly, you will learn to program in assembly language - the language of the computer itself. Assembly language is often thought of as a difficult and arcane subject. However, author Jonathan Bartlett presents the material in a way that works just as well for first-time programmers as for long-time professionals. Whether this is your first programming book ever or you are a professional wanting to deepen your understanding of the computer you are working with, this book is for you. The book teaches 64-bit x86 assembly language running on the Linux operating system. However, even if you are not running Linux, a provided Docker image will allow you to use a Mac or Windows computer as well. The book starts with extremely simple programs to help you get your grounding, going steadily deeper with each chapter. At the end of the first section, you will be familiar with most of the basic instructions available on the processor that you will need for any task. The second part deals with interactions with the operating system. It shows how to make calls to the standard library, how to make direct system calls to the kernel, how to write your own library code, and how to work with memory. The third part shows how modern programming language features such as exception handling, object-oriented programming, and garbage collection work at the assembly language level. Additionally, the book comes with several appendices covering various topics such as running the debugger, vector processing, optimization principles, a list of common instructions, and other important subjects. This book is the 64-bit successor to Jonathan Bartlett's previous book, Programming from the Ground Up, which has been a programming classic for more than 15 years. This book covers similar ground but with modern 64-bit processors, and also includes a lot more information about how high level programming language features are implemented in assembly language. What You Will Learn How the processor operates How computers represent data internally How programs interact with the operating system How to write and use dynamic code libraries How high-level programming languages implement their features.
650 0 $a Programming languages (Electronic computers). $3 1127615
650 0 $a Computer science. $3 573171
650 0 $a Computers. $3 565115
650 0 $a Software engineering. $3 562952
650 1 4 $a Programming Language. $3 1365750
650 2 4 $a Computer Science. $3 593922
650 2 4 $a Computer Hardware. $3 669779
650 2 4 $a Software Engineering. $3 669632
710 2 $a SpringerLink (Online service) $3 593884
773 0 $t Springer Nature eBook
776 0 8 $i Printed edition: $z 9781484274361
776 0 8 $i Printed edition: $z 9781484274385
856 4 0 $u https://doi.org/10.1007/978-1-4842-7437-8
912 $a ZDB-2-CWD
912 $a ZDB-2-SXPC
950 $a Professional and Applied Computing (SpringerNature-12059)
950 $a Professional and Applied Computing (R0) (SpringerNature-43716)