Mostrando postagens com marcador Curso de Assembly. Mostrar todas as postagens
Mostrando postagens com marcador Curso de Assembly. Mostrar todas as postagens

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


O que é e como usar um Label (rótulo) em Assembly

Agora que já vimos no artigo passado o escopo e organização de um programa em Assembly, vamos iniciar nossos estudos em programação mesmo, com exemplos reais de códigos ou trechos de código-fonte.

Neste tutorial de nosso curso Assembly Progressivo, vamos iniciar os nossos estudos das instruções em Assembly, explicando o que são os labels, labels internos (ou locais), dando exemplos de uso e mostrando para que servem.

O que são labels em Assembly e para quê servem

A tradução de label é 'rótulo', é uma nomenclatura que damos para dar nome a um trecho de código em Assembly.


Durante todo nosso curso de Assembly iremos traduzir algumas palavra dessa linguagem de programação, pois simplesmente entendendo o significado da palavra em inglês, saberemos a utilidade daquele comando.


O label, por exemplo, serve (como o nome diz) para rotular, nomear uma seção do código, para que possamos definir uma região do código através de um rótulo, de um nome que quisermos.


Para criar uma label, basta digitar o nome desse rótulo seguido de dois pontos, ' : '.

Em seguida, escrevemos nossas linhas de código em Assembly.


A sintaxe é a seguinte, então:


label:
 ;aqui vem o código
 ;que vai ser nomeado
 ;de 'label'
































Imagine que você criou uma rotina de códigos que tem por objetivo passar um número para outro registrador, subtrair esse valor daquele e depois substituir o valor original (não importa o que sua rotina esteja fazendo). Enfim, suponha que você criou um trecho de código que vai repetir várias vezes durante seu programa em Assembly.


Ou seja, esse código se repete, você vai usar mais de uma vez.
Vamos então criar um label chamado 'rotinaBase'.


rotinaBase:
  ;código super
  ;hiper mega complexo
  ;que aprendi no
  ;Assembly Progressivo




O que o label faz é nomear essa porção de linhas de código.

Para executar elas, em vez de escrever todas elas de novo em outra parte, você apenas se refere a "rotinaBase", e o trecho de código que você usou abaixo da label 'rotinaBase' será executado.


Lembrando que a linguagem Assembly está em baixo nível, ela sempre trata tudo em relação aos endereços na memória.Os labels estão intrinsecamente ligados com endereços de memória.


Um label serve para representar o endereço de um determinado trecho no código (ou para inicializar variáveis e constantes que podem ter seus endereços realocados).

Assim, se usarmos esse trecho de código várias vezes, em vez de repeti-lo basta voltar ao ponto (endereço) na memória que tem esses códigos.


Porém, é complicado para os humanos tratarem os endereços de memórias como números (em binário, hexadecimal ou mesmo decimal), por isso damos um nome a esse endereço de memória, um rótulo, e passamos a chamar esse local da memória pelo seu label. Bem mais simples, não?

No nosso código do Hello World em Assembly, usamos o label '_start', que serve para definir para o NASM onde vai começar nosso programa.

Como outro exemplo do uso de label em nossos códigos Assembly, vamos supor que durante a execução de um programa seja necessário incrementar uma variável 'numero' várias vezes.

O código para incrementar é:


inc numero ;numero++



Onde 'inc' é um mnemônico, ou seja, representa a operação de incrementação (adicionar +1 à variável 'numero'). Vamos criar um label para definir esse trecho de código, a label: 'incrementa'.

Ela ficaria assim:



incrementa:
  inc numero ;incrementa 'numero' em uma unidade




Pronto, agora podemos incrementar a variável número apenas invocando o label.



Labels internas ou Labels locais







O uso de labels é altamente recomendável, visto que os programas em baixo nível sempre são enormes, com códigos 'obscuros', números hexadecimais e outras complicações visuais.



Em sistemas mais complexos, onde é necessário o uso de centenas ou milhares de linhas de código, será interessante usar labels internas.

Você usará labels que vão representar centenas de linhas de código, e pode ser necessário usar labels dentro destas labels, e provavelmente que tenham o mesmo nome.



O NASM, que é o Assembler que estamos usando em nosso Curso de Assembly, permite a definição de labels locais.

Para isso, basta colocar um ponto, ' . ', antes do nome da label.



labelNormal -> label normal, sem ponto

.labelInterna -> label local, com ponto, ela está dentro('pertence) a label 'labelNormal'



Por exemplo, uma representação de um código que duas labels internas, de mesmo nome, mas em locais diferentes, que fazem a mesma coisa (incrementar), mas incrementam variáveis diferentes:



trecho1:
 ;trecho 1 do código
.incrementa:
 inc numero1 
 
 ;continuação trecho 1
 
trecho2:
 ;trecho 2 do código
.incrementa:
 inc numero2
 
 ;continuação do trecho 2


Note que uma label local se refere a label 'geral', imediatamente superior.

Cuidado para não se confundir.



Nossos estudos sobre labels não param por aqui, mas você já aprendeu uma ótima noção sobre os rótulos, embora ainda falte coisas importantes, como o ret, que é uma instrução de retorno, que serve para definir onde termina um rótulo/label.



Ao decorrer de nossa apostila online de Assembly usaremos bastante labels, então você aprenderá mais sobre elas vendo exemplos reais de código.

Sections e _start: A divisão do código-fonte Assembly - A diretiva global

Quando um executável vai rodar, ele precisa saber a partir de onde, no código, ele começa a rodar.

Em programação, começar do começo não é algo comum.

Tendo em vista esses dados sobre a informação da ordem das coisas em um código, vamos falar neste tutorial de Assembly sobre as seções (sections) de um arquivo-fonte em Assembly.


Deixando seu código organizado

Programas feitos na linguagem de baixo nível Assembly tem uma características em comum: eles são grandes.


Sim, programar em Assembly é escrever bastante, pois é uma linguagem totalmente crua, onde muito pouco 'existe' e muito, quase tudo, é necessário criar.

Para se fazer um simples programa de cálculos matemáticos simples (somar, subtrair etc) é necessário que fazer uma rotina, manualmente, para essa tarefa, usando somente as instruções nativas do processador.


Em linguagens de alto nível, como C e Java, isso já vem totalmente pronto.

Não é necessário criar nada, somente utilizar.


Então, mais que todas as outras linguagens, é necessário ter organização para programar em Assembly. Seu código deve ser legível, organizado e comentado.


Visando essa organização, existe um comando (ou simplesmente rótulo, ou marcador) chamado section, que serve para definirmos seções em nosso código.

Para declarar uma section fazemos:
section .nomeDaSecao






























Como dividir um código Assembly: .data, .bss e .text

De uma maneira geral, os programadores Assembly utilizam três sections para organizar seus códigos. Seguir esses passos é interessante, visto que fará com que seus programas sejam organizados da maneira padrão, da maneira que é universalmente usada.



Na .data section, como o nome sugere, é uma região do código que será usada para tratar as informações, os dados, as variáveis.

Nesse trecho (geralmente o inicial), declaramos e inicializamos as variáveis.


Fazemos algo parecido na .bss section, porém não inicializamos as informações.


Por fim, a .text section é o local onde irá ficar armazenado suas instruções, que irão trabalhar com os dados previamente declarados.

Essa é a única seção obrigatória, pois conterá a label (rótulo) _start, que é o local onde os executáveis são inicializados.


Se já estudou C, C++ ou Java, por exemplo, a _start seria o main().

Logo, o esqueleto dos códigos em Assembly é:

section .dat
  ;declaração e inicialização de dados
 
section .bss
  ;declaração sem inicialização das informações que serão usadas
 
section .text
  ;o programa começa a rodar aqui, a partir da _start


Se comunicando com o mundo externo: global

Como as memórias e processadores estão ficando cada vez mais modernos e maiores (em relação ao tamanho da memória), está possível, cada vez mais, usar linguagens de alto nível (principalmente o C), para tarefas que eram feitas exclusivamente em Assembly.


Uma prova disso é o sistema operacional Linux, onde sua gigantesca parte é feita em C, com algumas pitadas em Assembly.

Essa pitada de Assembly no Kernel é justamente na parte que é necessária uma maior eficiência da máquina, pois como sabemos, em termos de eficiência nenhuma outra linguagem bate nossa amada linguagem.


Por isso, é bem comum a interação entre Assembly e outras linguagens. Um exemplo disso são os games de alto desempenho, que possuem rotinas feitas em Assembly, que se comunica com o resto do programa.

Ainda em nosso curso de Assembly veremos como usar funções das bibliotecas da linguagem C.


Uma maneira de fazer essa interação é através da diretiva (explicaremos o que é isso em breve) global.

A diretiva global mostra que o label relacionado é global, ou seja, é passível de uso externamente.

Geralmente usamos para declarar o label principal, o _start.

Portanto, o nosso esqueleto de código será:


section .dat
  ;declaração e inicialização de dados
 
section .bss
  ;declaração sem inicialização das informações que serão usadas
 
section .text
global _start
 
_start:
  ;o programa começa a rodar aqui, a partir daqui



Assembly é a melhor linguagem de programação?

É comum vermos na internet, principalmente em fóruns,
pessoas falando que linguagem X é melhor que Y, que Y paga melhor que a
linguagem Z, que linguagem isso é
mais ‘foda’ que linguagem aquela.

Ignore, totalmente, esses tipos de comentários e pessoas.
Não existe melhor linguagem, existem linguagens e
tecnologias mais indicadas para cada tipo de problema.


Qual é a melhor linguagem de programação?

Vamos traçar um paralelo, com veículos de locomoção.

Um avião é bem mais veloz que um carro, óbvio não?
Além disso, é mais eficiente e seguro. Mas isso vai exigir
um custo (financeiro, burocrático, estudo etc) bem maior.
Devemos usar, então, o avião para viajar? Depende da viagem.





Já um carro é bem mais barato e não é tão caro pra manter
quanto um avião.
Mas é bem mais lento, perigoso e menos eficiente.
Mas é fácil de dirigir um, e não precisa de muito estudo,
apenas temos que tirar a carteira de habilitação.
Ora, se é mais barato e prático, devemos usar carros para
viajar? Depende da viagem.

Já uma bicicleta é bem, mas bem, mais barata. Não precisa
gastar dinheiro para usá-la, nem é necessário ter uma idade mínima, habilitação
ou sequer idade mínima para se deslocar numa bike.
Ora, se é praticamente de graça viajar em uma bicicleta,
devemos usá-la para viajar?
Depende da viagem.

Tenho certeza que você entendeu os dependes dos exemplos
anteriores, bem como tem bom senso suficiente para saber quando usar um ou
outro.
Para viagens longas entre lugares distantes, avião sem
dúvidas é a melhor opção.
Para ir a outra cidade, ou viajar para o interior ou
literal, é mais cômodo ir de carro.
Já para ir pra escola ou andar alguns quarteirões, a
bicicleta é a melhor alternativa.

Então, qual desses veículos é o melhor?
A resposta é: não existe melhor, existe solução mais
adequada para cada tipo de situação.

Com esse exemplo, é bem fácil entender, mas geralmente as
pessoas não levam isso para o mundo da programação, e nesse âmbito a situação é
a mesma: você tem que ver seu problema e analisar qual a melhor solução para
ele
.No caso, qual melhor linguagem, tecnologia e o melhor
meio para abordar tal problema.
Portanto, dizer que linguagem A ou B é melhor, é dar um
atestado de sua ignorância e estará carimbando seu documento de leigo poser.

Porém, a linguagem Assembly é bastante respeitada e
considerada por muitos como a melhor, principalmente por engenheiros,
escovadores de bits (pessoas que amam computação, e querem saber tudo que
ocorre, nos mínimos detalhes, em suas máquinas) e por hackers.

No próximo artigo de Assembly entraremos em detalhes sobre
as vantagens dessa linguagem, bem como suas desvantagens.
Sim, como todas as linguagens, há desvantagens em usar o
Assembly. Não se iluda.

























Onde o Assembly age: Níveis de abstração na Computação

Para entender um pouco mais de Assembly, precisamos
explanar os diversos níveis de abstração que um computador possui. Dentro dessa
ordem de níveis, o Assembly se encontra mais abaixo, mais próximo do hardware,
por isso é dito ser uma linguagem de baixo nível.

Para entender melhor, vamos começar de cima, de onde você
provavelmente deve estar agora, ao ler esse tutorial de Assembly.


A camada dos softwares e aplicações de alto nível

Aqui é onde está a maioria dos usuários de computadores,
tipicamente lidando com aplicações gráficas, clicando em botões, menus,
minimizando, maximizando, fechando janelas, navegando na  web e outras infinidades de coisas.






Nesse estágio, as coisas são bem simples e voltadas para
o usuário leigo.
Não é necessário saber absolutamente nada sobre o
funcionamento interno dos sistemas. E, de fato, a grande maioria dos usuários
não sabe.

Para o usuário, é tudo a mesma coisa, não importa se ele
esteja no Windows, MacOS, Linux, Android ou TV Digital: ele quer ver menus,
botões, clicar, arrastar, fechar e o mesmo de sempre.
Uma mera tela preta, como a do MS-DOS ou Terminal do
Linux, já seria motivo de espanto e repúdio. Nesse estágio, as coisas são
voltadas para o agrado desse tipo de usuário, que mesmo sendo totalmente
leigos, são os que sustentam o ramo da computação.

E realmente, a grande maioria das pessoas não tem motivos
para entender o que se passa por debaixo dos panos dessas aplicações: são
médicos, advogados, professores exibindo slides nas aulas, caixas de
supermercado e praticamente todo tipo de profissional vai ter contato com essa
camada.

A camada das linguagens de alto nível

Quando pensamos em programar, geralmente pensamos em criar
um super jogo, um programa bem útil ou aplicação móbile. Pensamos em criar algo
para a camada de softwares de alto nível, pois é o que mais estamos acostumados
a lidar.

Para fazer programas desse tipo, de alto nível, usamos
linguagens de programação de alto nível, como Java, linguagem C, C++, C#, Python, Pascal,
Delphi, Visual Basic, JavaScript, PHP e outras linguagens famosas.

Os programados dessas linguagens são capazes de criar
entender como funcionam os softwares de alto nível em um nível não muito
profundo, pois não é necessário entender muito do funcionamento dos sistemas
operacionais.

Na linguagem de programação Java, por exemplo, você nem
precisa se importar com o sistema, pois é uma linguagem multi-plataforma, ou
seja, uma aplicação feita em Java pode rodar em Windows, Linux, Mac, celulares
etc, com poucas ou nenhuma alterações.

Essas duas camadas de abstração são, portanto,
independente da arquitetura do sistema.
Um programador Java, por exemplo, não precisa saber qual
o processador da máquina que vai programar, e nem como funciona a arquitetura
de seu sistema. São níveis de abstração que não dependem do sistema.























Camada da linguagem Assembly

Essa camada é o objetivo de nossa apostila de Assembly, e
diferente das outras linguagens, precisamos saber que tipo de arquitetura vamos
trabalhar.

Isso porque os comandos e códigos que vamos usar na
linguagem Assembly são diferentes e específicos para cada tipo de processador.
Ou seja, o nível de abstração da camada da linguagem Assembly é dependente do
sistema.
É tão dependente que até precisamos saber como é
organizada e o funcionamento da memória da máquina onde vamos programar.

Por isso não existem cursos para todos os tipos de
Assembly, a linguagem varia de acordo com cada máquina. Diferente da linguagem
Java ou C++, que não importa o tipo de computador para programar.

Por estar abaixo das aplicações gráficas, das linguagens
que criam essas aplicações e ser dependendo do sistema, a linguagem de
programação Assembly é dita de baixo nível.

A camada do código de máquina

Você já deve ter ouvido falar que tudo, absolutamente
tudo, em computação, é feito de números 1 e 0. E isso é verdade.
O computador (no sentido bem baixo da palavra, ou seja, o
metal, as peças eletrônicas) só entende e obedece a esses comandos, que nada
mais são que uma série de números binários (1’s e 0’s). Porém, quantas vezes
você já programou ou ouviu falar de alguém que programa em binário?

O objetivo da linguagem Assembly é suprir esse problema
da alta complexidade do binário.
Com o Assembly escrevemos de uma maneira mais ‘humana’,
mais fácil e compreensível, e esse código é convertido para o código de
máquina.

Esse é o limite dos programadores. Porém, há muito, mas
muito mais abaixo do Assembly, que envolvem coisas de elétrica e eletrônica
digital (latches, flip-flops, transistores, circuitos integrados etc). Quem se
interessar por esse meio, poderá adquirir conhecimentos através de cursos como
Engenharia de Computação, Engenharia Elétrica, Engenharia Eletrônica e cursos
do gênero.