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

2 comentários:

Wesley Marques disse...

Olá, me chamo Wesley e estou começando a aprender a arte da programação em c, porém eu gostaria muito de aprender também o Assembly já que essas duas linguagens parecem se tornar uma ferramenta poderosíssima estando em conjunto, e outra o Assemble foi a primeira linguagem da qual eu me interessei, agora eu estou pretendendo comprar esse livro "Linguagem C - 10ª Edição 2007" através do link do site c progressivo, eu gostaria muito de comprar junto com o livro de c este livro de Assemble, porém caras no momento não posso estudar o inglês. Então gostaria que vcs se possível me descem outra dica para um outro livro que fale também sobre o Assemble mais que seja em português. Valeu muito obrigado e aguardo uma resposta.

Curso Assembly Progressivo disse...

Olá Wesley,

Antes de mais nada, gostaríamos de parabenizar você pelo interesse nessas linguagens de baixo nível, certamente não vai se arrepender de estudá-las.

Sobre os livros, infelizmente não há muita coisa em português, pra falar a verdade só encontramos um livro em português sobre Assembly.

É sim um livro muito bom, boa leitura, mas o livro em inglês é mais completo, sem dúvidas.
Mas como você não lê em inglês, com certeza o livro em português é uma ótima fonte.

O nome dele é "Fundamentos da Programação em Assembly":
Fundamentos da Programaçẽo em Assembly

Também existe esse:
Livro Programação Asssembly
Mas não encontramos ele na biblioteca, então não pudemos avaliar, como fizemos com o livro anterior.

Mas, sem dúvidas, uma boa dica para você é ir estudando em inglês, sem dúvida os melhores livros e tutoriais de programação estão em inglês. Vale a pena!