O livro Professional Assembly Language é bom?

Análise e review completo do livro, curso Assembly ProgressivoOk, é um fato: existe poucas pessoas interessadas em estudar Assembly, poucas que sabem, menos ainda pessoas que explicam bem e livros do assunto são simplesmente raros.


Embora a literatura seja pouca (até mesmo na internet), existem bons materiais disponíveis e é sobre um desses materiais que vamos fazer agora um review, o excelente livro: Livro Professional Assembly Language






Livros são importantes para aprender Assembly ?

Não importa que linguagem deseja estudar, se quer realmente aprender será necessário estudar bastante e pelo maior número de fontes possíveis, como nosso curso Assembly Progressivo, vídeo-aulas, materiais e links que indicamos.



É simplesmente impossível dominar uma linguagem tendo estudando somente por uma fonte.



E não importa também a linguagem que deseja aprender: os livros ainda são as fontes mais completas e confiáveis de conhecimento. Existe muita coisa na internet, mas fragmentadas e muitos erros.



A grande vantagem dos livros é que eles começam, a maioria, bem do início mesmo, fornecendo informações básicas para o leitor, leigo ou não. Os assuntos se desenvolvem de forma gradual, com exemplos de códigos, exercícios e sua resoluções.



E mesmo que seja um profissional de Assembly, é praticamente impossível lembrar tudo, até porque estudar Assembly é estudar arquitetura, organização da memória, modos de endereçamento, registros e outros detalhes mais, que nenhuma outra linguagem exige.



E é nesse ponto que o Livro Professional Assembly Language é importante para os que não são leigos: ele serve como uma verdadeira fonte de consulta, que você deve ter próximo para relembrar e confirmar detalhes sempre que precisar.



Por isso não tenha dúvidas.

 Clique aqui e obtenha já seu Livro Professional Assembly Language































O Livro Professional Assembly Language é bom? Para quem é indicado? O que se aprende nele?

O Livro Professional Assembly Language é, sem dúvidas, um dos mais (se não for o mais) completos livros sobre a linguagem.



E convenhamos, o Assembly não é a linguagem mais simples de se aprender, ela exige muito estudo de hardware e entendimento do que ocorre em sua máquina, nos mínimos detalhes.

E são esses detalhes que compõem o diferencial do livro, pois cobre desde assuntos básicos como a plataforma IA32, conversão de números (binários, hexadecimais e decimais), linker, compiler, debugging, integração com o C e outros assuntos mais, que geralmente passam batidos por tutoriais da internet.



Os exemplos de código são inúmeros, e todos muito bem comentados, onde um passo só é dado quando o anterior foi completamente esmiuçado, explicado e entendido pelo leitor, tornando uma leitura agradável.



O livro Professional Assembly Language é particularmente importante para quem não pode frequentar um curso ou faculdade, mas que deseja aprender essa bela linguagem por interesse e força de vontade própria, não deixando seu leitor a desejar em nada quando falamos em conhecimento da linguagem Assembly.



Os contras do livro Professional Assembly Language

Alguns detalhes dos livros, podem vir a atrapalhar o leitor, mas nada de muito sério. O mais importante, que é sua clareza e qualidade, são garantidos por inúmeras faculdades que adotam este livro como o padrão.



Assim como na maioria dos assuntos bem mais técnicos e aprofundados, este livro está totalmente escrito em inglês.

Porém, por ser um livro de técnico de computação, sua linguagem é bem científica e de fácil entendimento, mas para uma pessoa que tenha apenas conhecimentos básicos de inglês.



E caso você não tenha uma noção em inglês, recomendamos fortemente que você aproveite esta oportunidade para aprender inglês, ao passo que começa a programar em Assembly.

Leia o artigo "A melhor e mais importante linguagem programação do mundo" para saber a importância do inglês no estudo da computação.



Outro aspecto a se levar em consideração é que ele é voltado para usuários do sistema operacional Linux, pois se utiliza de softwares GNU, como o compiler (gcc), assembler (gas), linker (ld), e o debugger (gdb).

Porém, o mais importante, que são as ideias e explicações sobre a linguagem Assembly, podem ser facilmente usados e entendidos mesmo por usuários de outros sistemas operacionais.



Provavelmente Assembly não será sua primeira linguagem de programação, visto que não é uma linguagem famosa nem muito simples para os iniciantes. Então temos um aspecto que pode ser um pouco negativo, caso você não saiba C ou C++: o livro Professional Assembly Language foca nos leitores que já estudaram essa linguagem.



Porém, se você já tiver estudado (o que é bem provável), ficará maravilhado com este livro, pois a todo momento o autor faz e explica a relação do estudo dos assuntos do Assembly com aquelas informações que você tem sobre C.

Ficamos sabendo, em detalhe, o que cada código em C faz por debaixo dos panos, no Assembly, nos levando à uma incrível compreensão destas duas belas linguagem e, claro, dos computadores.



Como a literatura é escassa, não podemos exigir material totalmente livre e de qualidade, sendo necessário fazer um investimento. Porém, esse é um investimento totalmente válido e já nas primeiras páginas você terá a certeza do maravilhoso trabalho que adquiriu.



Não tenha dúvidas, adquira já seu livro Professional Assembly Language.



Informações sobre o livro Professional Assembly Language

Autor: Richard Blum

Editora: John Wiley & Sons

I.S.B.N.: 0764579010

Cód. Barras: 9780764579011

Reduzido: 321562

Acabamento : Brochura

Edição : Feb-05

Idioma : Inglês

Número de Paginas : 546

Clique aqui para ter seu Professional Assembly Language, o melhor livro de Assembly



Índice de assuntos do livro Professional Assembly Language

Se ainda está em dúvida se vale a pena o investimento, apenas dê uma olhada no tanto de informações contidas nas mais de 500 páginas do livro Professional Assembly Language:




  Acknowledgments                    
  Contents                          
  Introduction
                   
Chapter 1: What Is Assembly Language?   

  Processor Instructions              

     Instruction code handling        

     Instruction code format          

  High-Level Languages                

     Types of high-level languages    

     High-level language features    

  Assembly Language                  

     Opcode mnemonics                

     Defining data                  

     Directives                      

  Summary



Chapter 2: The IA-32 Platform       

  Core Parts of an IA-32 Processor

    Control unit                  

    Execution unit                

    Registers                    

    Flags                        

  Advanced IA-32 Features        

    The x87 floating-point unit  

    Multimedia extensions (MMX)  

    Streaming SIMD extensions (SSE)

    Hyperthreading                

  The IA-32 Processor Family      

    Intel processors              

    Non-Intel processors          

  Summary                        







Chapter 3: The Tools of the Trade             

   The Development Tools                    

     The Assembler                          

     The Linker                            

     The Debugger                          

     The Compiler                          

     The object code disassembler          

     The Profiler                          

   The GNU Assembler                        

     Installing the assembler              

     Using the assembler                    

     A word about opcode syntax            

   The GNU Linker                          

   The GNU Compiler                        

     Downloading and installing gcc        

     Using gcc                              

   The GNU Debugger Program                

     Downloading and installing gdb        

     Using gdb                              

   The KDE Debugger                        

     Downloading and installing kdbg        

     Using kdbg                            

   The GNU Objdump Program                  

     Using objdump                          

     An objdump example                    

   The GNU Profiler Program                

     Using the profiler                    

     A profile example                      

   A Complete Assembly Development System  

     The basics of Linux                    

     Downloading and running MEPIS          

     Your new development system            

   Summary                                  





Chapter 4: A Sample Assembly Language Program 

   The Parts of a Program                  

     Defining sections                      

     Defining the starting point            

   Creating a Simple Program                

     The CPUID instruction                  

     The sample program                    

    Building the executable                            

    Running the executable                            

    Assembling using a compiler                        

  Debugging the Program                                

    Using gdb                                          

  Using C Library Functions in Assembly                

    Using printf                                      

    Linking with C library functions                  

  Summary        



                                   

Chapter 5: Moving Data                                   

  Defining Data Elements                              

    The data section                                  

    Defining static symbols                            

    The bss section                                    

  Moving Data Elements                                

    The MOV instruction formats                        

    Moving immediate data to registers and memory      

    Moving data between registers                      

    Moving data between memory and registers          

  Conditional Move Instructions                      

    The CMOV instructions                            

    Using CMOV instructions                          

  Exchanging Data                                    

    The data exchange instructions                  

    Using the data exchange instruction              

  The Stack                                          

    How the stack works                              

    PUSHing and POPing data                          

    PUSHing and POPing all the registers              

    Manually using the ESP and EBP registers        

  Optimizing Memory Access                          

  Summary                                            





Chapter 6: Controlling Execution Flow                  

  The Instruction Pointer                            

  Unconditional Branches                            

    Jumps                                            

    Calls                                            

    Interrupts                                        

  Conditional Branches                      

     Conditional jump instructions          

     The compare instruction                

     Examples of using the flag bits        

  Loops                                    

     The loop instructions                  

     A loop example                          

     Preventing LOOP catastrophes          

  Duplicating High-Level Conditional Branches

     if statements                          

     for loops                              

  Optimizing Branch Instructions            

     Branch prediction                      

     Optimizing tips                        

  Summary                                  





Chapter 7: Using Numbers                      

  Numeric Data Types                        

  Integers                                  

     Standard integer sizes                

     Unsigned integers                      

     Signed integers                        

     Using signed integers                  

     Extending integers                    

     Defining integers in GAS                

  SIMD Integers                            

     MMX integers                            

     Moving MMX integers                    

     SSE integers                          

     Moving SSE integers                    

  Binary Coded Decimal                      

     What is BCD?                          

     FPU BCD values                        

     Moving BCD values                      

  Floating-Point Numbers                    

     What are floating-point numbers?      

     Standard floating-point data types    

     IA-32 floating-point values            

     Defining floating-point values in GAS  

     Moving floating-point values            

     Using preset floating-point values    

     SSE floating-point data types                

     Moving SSE floating-point values              

  Conversions                                      

     Conversion instructions                        

     A conversion example                          

  Summary                                          





Chapter 8: Basic Math Functions                      

  Integer Arithmetic                              

     Addition                                      

     Subtraction                                  

     Incrementing and decrementing                

     Multiplication                              

     Division                                      

  Shift Instructions                              

     Multiply by shifting                          

     Dividing by shifting                          

     Rotating bits                                

  Decimal Arithmetic                              

     Unpacked BCD arithmetic                      

     Packed BCD arithmetic                        

  Logical Operations                            

     Boolean logic                              

     Bit testing                                  

  Summary                                          





Chapter 9: Advanced Math Functions                   

  The FPU Environment                              

     The FPU register stack                        

     The FPU status, control, and tag registers    

     Using the FPU stack                            

  Basic Floating-Point Math                        

  Advanced Floating-Point Math                    

     Floating-point functions                      

     Partial remainders                          

     Trigonometric functions                      

     Logarithmic functions                          

  Floating-Point Conditional Branches            

     The FCOM instruction family                    

     The FCOMI instruction family                

     The FCMOV instruction family                  

  Saving and Restoring the FPU State        

      Saving and restoring the FPU environment

      Saving and restoring the FPU state    

  Waiting versus Nonwaiting Instructions    

  Optimizing Floating-Point Calculations    

  Summary                                    





Chapter 10: Working with Strings               

  Moving Strings                            

      The MOVS instruction                    

      The REP prefix                          

      Other REP instructions                  

  Storing and Loading Strings                

      The LODS instruction                    

      The STOS instruction                    

      Building your own string functions    

  Comparing Strings                          

      The CMPS instruction                    

      Using REP with CMPS                    

      String inequality                      

  Scanning Strings                          

      The SCAS instruction                    

      Scanning for multiple characters        

      Finding a string length                

  Summary                                    





Chapter 11: Using Functions                    

  Defining Functions                        

  Assembly Functions                        

      Writing functions                      

      Accessing functions                    

      Function placement                      

      Using registers                        

      Using global data                      

  Passing Data Values in C Style            

      Revisiting the stack                    

      Passing function parameters on the stack

      Function prologue and epilogue        

      Defining local function data            

    Cleaning out the stack                      

    An example                                  

    Watching the stack in action                

  Using Separate Function Files                

    Creating a separate function file          

    Creating the executable file                

    Debugging separate function files          

  Using Command-Line Parameters                

    The anatomy of a program                    

    Analyzing the stack                        

    Viewing command-line parameters            

    Viewing environment variables              

    An example using command-line parameters    

  Summary                                      





Chapter 12: Using Linux System Calls              

  The Linux Kernel                              

    Parts of the kernel                          

    Linux kernel version                        

  System Calls                                  

    Finding system calls                        

    Finding system call definitions              

    Common system calls                          

  Using System Calls                            

    The system call format                      

  Advanced System Call Return Values            

    The sysinfo system call                    

    Using the return structure                  

    Viewing the results                          

  Tracing System Calls                          

    The strace program                          

    Advanced strace parameters                  

    Watching program system calls              

    Attaching to a running program              

  System Calls versus C Libraries              

    The C libraries                              

    Tracing C functions                        

    Comparing system calls and C libraries      

  Summary                                      







Chapter 13: Using Inline Assembly             

   What Is Inline Assembly?                

   Basic Inline Assembly Code              

     The asm format                          

     Using global C variables                

     Using the volatile modifier            

     Using an alternate keyword              

   Extended ASM                            

     Extended ASM format                    

     Specifying input and output values      

     Using registers                        

     Using placeholders                      

     Referencing placeholders                

     Alternative placeholders                

     Changed registers list                  

     Using memory locations                  

     Using floating-point values            

     Handling jumps                          

   Using Inline Assembly Code              

     What are macros?                        

     C macro functions                      

     Creating inline assembly macro functions

   Summary                                  





Chapter 14: Calling Assembly Libraries        

   Creating Assembly Functions              

   Compiling the C and Assembly Programs    

     Compiling assembly source code files  

     Using assembly object code files        

     The executable file                    

   Using Assembly Functions in C Programs  

     Using integer return values            

     Using string return values              

     Using floating-point return values      

     Using multiple input values            

     Using mixed data type input values      

   Using Assembly Functions in C++ Programs

   Creating Static Libraries                

     What is a static library?              

     The ar command                          

    Creating a static library file                

    Compiling with static libraries                

  Using Shared Libraries                          

    What are shared libraries?                    

    Creating a shared library                      

    Compiling with a shared library              

    Running programs that use shared libraries    

  Debugging Assembly Functions                    

    Debugging C programs                          

    Debugging assembly functions                  

  Summary                                        





Chapter 15: Optimizing Routines                     

  Optimized Compiler Code                        

    Compiler optimization level 1                  

    Compiler optimization level 2                  

    Compiler optimization level 3                  

  Creating Optimized Code                        

    Generating the assembly language code        

    Viewing optimized code                        

    Recompiling the optimized code                

  Optimization Tricks                            

    Optimizing calculations                        

    Optimizing variables                          

    Optimizing loops                              

    Optimizing conditional branches                

    Common subexpression elimination              

  Summary                                        





Chapter 16: Using Files                             

  The File-Handling Sequence                      

  Opening and Closing Files                      

    Access types                                  

    UNIX permissions                              

    Open file code                                

    Open error return codes                        

    Closing files                                  

  Writing to Files                                

    A simple write example                        

    Changing file access modes                    

    Handling file errors                          

  Reading Files                              

    A simple read example                      

    A more complicated read example            

  Reading, Processing, and Writing Data        

  Memory-Mapped Files                          

    What are memory-mapped files?              

    The mmap system call                        

    mmap assembly language format              

    An mmap example                            

  Summary                                      





Chapter 17: Using Advanced IA-32 Features        

  A Brief Review of SIMD                      

    MMX                                        

    SSE                                        

    SSE2                                        

  Detecting Supported SIMD Operations          

    Detecting support                          

    SIMD feature program                        

  Using MMX Instructions                      

    Loading and retrieving packed integer values

    Performing MMX operations                  

  Using SSE Instructions                      

    Moving data                                

    Processing data                            

  Using SSE2 Instructions                      

    Moving data                                

    Processing data                            

  SSE3 Instructions

  Summary


Nenhum comentário:

Tutoriais de Programação