Como os backlinks ajudam o seu SEO

Ter à sua disposição uma empresa que disponibiliza uma boa hospedagem de site é muito importante para o seu blog ou site, pois desse modo o seu projeto pode contar com recursos relevantes, tais como mais espaço em disco, contas de e-mail e backups.

Porém, não adianta ter todas as funcionalidades que poderão possibilitar que o seu site suporte elevados picos de acesso se ele raramente é visitado.

Pense o quanto deve ser frustrante para um empreendedor que não vê as vendas crescerem na sua loja virtual. Isso é algo tão desanimador quanto o gerente de uma loja física manter as portas abertas do seu empreendimento e não ver ninguém entrar.

Porém, no caso de quem tem um e-commerce ou até mesmo um blog pessoal, existem maneiras de adquirir a tão sonhada presença digital. A maneira mais eficiente para isso é utilizando as técnicas de SEO.

Search Engine Optimization, como essas técnicas são chamadas em inglês, consistem no uso adequado de palavras-chaves em suas postagens. Ao utilizar palavras-chaves referentes ao seu conteúdo, o seu site será bem posicionado nas páginas de resultado de sites como Google, Yahoo e Bing.

A importância do Link Building

Saber como criar um blog não é difícil. Atualmente existe a plataforma WordPress que é intuitiva, responsiva e facilita esse trabalho. O WordPress, inclusive, conta com uma série de plugins que agregam mais funcionalidades para o seu blog.

Como obter backlinks

O Yoast Seo, nesse caso, é um desses plugins. Ele existe para facilitar você a encontrar as palavras-chaves mais adequadas para o seu blog. No entanto, não é apenas de Keywords que se mantém  uma eficiente estratégia de SEO.

É aí que o Link Building entra em ação. O Link Building, que pode ser traduzido como “Construção de Links” e consiste em estratégias que utilizam os chamados backlinks nas práticas de SEO.

Os backlinks são links que conduzem o usuário para uma página no seu site, resultando com isso em tráfego orgânico, mostrando para o Google que a sua página tem relevância.

Por isso, se engana quem pensa que quando o assunto é SEO os backlinks são meros coadjuvantes. Eles indicam para os algoritmos de busca a popularidade e a relevância de um domínio.

Sendo assim, é válido ter em mente que existem os backlinks externos e os backlinks internos. Os externos são links existentes em outros sites e blogs que conduzem o usuário para o seu.

Por outro lado, os backlinks internos consistem em links presentes nas postagens do seu blog que conduzem para postagens mais antigas, sempre com o objetivo de mencionar ou acrescentar mais informações para essas postagens.

Enfim, utilizar backlinks nas suas páginas é como se você estivesse falando com o Google, dizendo “veja como eu também tenho conteúdo relevante”. Sendo assim, para utilizar os backlinks como uma estratégia eficiente, as dicas são:

  • Faça parceria com outros sites e blogs

Entre em contato com outros espaços da internet que possuem uma boa reputação e fazem parte do mesmo nicho que o seu. Ter um link seu em tais sites confere relevância para o seu conteúdo.   

Os Guest Posts, também conhecidos como “Postagens Convidadas” também enriquecem a parceria e traz mais qualidade para os projetos de todos os envolvidos.

  • Trabalhe os Backlinks Internos

Os Backlinks presentes em seu blog são importantes porque induzem o usuário a visitar postagens mais antigas, aumentando o número de visualizações em seu blog. Além disso, eles agregam informações para um determinado assunto.

Mas nem por isso você deve exagerar na dose entupindo as suas postagens com Backlinks a cada parágrafo ou frase.

Lembre-se também de não utilizar “iscas manjadas” para os backlinks, tais como “clique aqui”, ou “visite aqui”. É possível atrair os leitores utilizando frases diretas e de maneira orgânica.

  • Não compre Backlinks

Sim, existe a possibilidade de comprar backlinks. A compra de backlinks definitivamente não é uma boa ideia. É importante que os links sejam compatíveis com o conteúdo que você produz.

Outro detalhe importante é que tal compra não está de acordo com as diretrizes do Google. Por isso, o importante mesmo é você mesmo criar os seus próprios backlinks.

  • Atenção para a origem dos Backlinks

É interessante evitar receber backlinks sempre do mesmo site. O ideal é investir na variedade até porque, acredite, o Google pode comparar perfis de backlinks e considerar a repetição uma estratégia suspeita.

Uma dica para escolher sites relevantes e variados para os seus Backlinks é utilizar a métrica do DA (Domain Authority) que a ferramenta SEMrush disponibiliza.

O fato é que quanto maior o Domain Authority, mais relevância ele vai conferir para o seu. Ah! E se você não sabe o que é o SEMrush, vale mencionar que, de forma bem resumida, ele é um software capaz de analisar a relevância das palavras-chaves.  

Conclusão

O Google é exigente. Ele preza pela qualidade e originalidade de conteúdo para posicionar bem um blog nas suas páginas de resultado.

Portanto, além do cuidado que você deve ter com as palavras-chaves nas suas estratégias de SEO, preste atenção também no uso adequado dos backlinks.



Ler Tutorial

Como criar sites: HTML, CSS e o Desenvolvimento Web

Como criar um siteAté o momento, em nossa seção sobre Como começar a programar, falamos sobre diversas linguagens de programação voltadas para o desenvolvimento desktop, como C, C++, Java e C#.

Agora vamos mostrar outro tipo de desenvolvimento, voltado para a internet.

É o desenvolvimento Web, cuja base é a famosa linguagem de marcação HTML.
Ler Tutorial

Imprimindo informações na Tela: PRINT e SAY em Perl

Neste tutorial de Perl, vamos aprender como exibir informações no terminal de comando, usando as funções print e say, do Perl.

Imprimindo informações no terminal de comando

print, em inglês, significa imprimir.

Imprimir, pra gente, lembra muito fazer uma impressão, numa impressora, né?
Na verdade, é um termo mais amplo, significa exibir.

Assim, quando falamos em imprimir ou printar, estamos falando em simplesmente mostrar alguma informação, um texto, um número ou qualquer coisa.

É a primeira maneira que aprenderemos sobre como trocar informações entre a máquina e a pessoa que está utilizando ela. Todos os comandos e operações, ocorrem 'escondidos', no hardware de seu computador, então usamos algum comando que exibe pra gente esses resultados.

As maneiras mais comuns de exibir dados de informação são através das função print e say, em Perl, que simplesmente mostram na tela do terminal de comando as informações que quisermos, vamos lá aprender como usá-las ?

A função print do Perl

Essa função (comando que faz alguma coisa específica) nós já usamos no tutorial de como programar o script Olá, mundo! em Perl.

Basta digitar o comando print e escrever qualquer coisa entre aspas duplas ou simples e terminar o comando com o ponto-e-vírgula ;
Prontinho. Vai aparecer na tela o que você digitou entre as aspas.

Esses textos, em Perl, são chamados de strings.

Teste:
#!/usr/bin/perl
print "Curso Perl Progressivo";
O resultado vai ser:
Curso Perl Progressivo

Porém ficou feio, pois ficou 'colado' com uma linha de texto do terminal de comando.

Caractere de quebra de linha: \n

Parece resolvermos esse problema, basta darmos um 'enter' dentro da string.

O enter, em computação, é simbolizado por: \n
Sempre que o Perl lê esse comando, ele dá um pulo, uma quebra de linha.

Experimente:
#!/usr/bin/perl
print "Curso Perl Progressivo \n";
O resultado foi o que vimos no tutorial passado, bem mais bonitinho e organizado, não é?

E para exibir o resultado abaixo:
Curso de Perl online grátis

Como você programaria o script em Perl abaixo ?
Você pode fazer tanto assim:
#!/usr/bin/perl
print "Bem vindos ao curso: \n";
print "Perl Progressivo \n";
Como tudo em uma linha só, veja:
#!/usr/bin/perl
print "Bem vindos ao curso:\nPerl Progressivo\n";

A função SAY do Perl

Programador é um bicho preguiçoso. Gosta de fazer tudo da maneira mais rápida, simples e econômica possível, quanto menos trabalho, melhor.

Como se a função print já não fosse simples o bastante, inventaram a função say.
Troque print por say e veja o resultado:
#!/usr/bin/perl
use v5.010;
say "Curso Perl Progressivo";
Notou?
Ela, automaticamente, já dá a quebra de linha ao final, não precisa usar o caractere \n de quebra de linha.
Bacana, não?

Exercícios de PRINT em Perl

1. Frase na tela - Implemente um programa que escreve na tela a frase "O primeiro programa a gente nunca esquece!".

2. Etiqueta - Elabore um programa que escreve seu nome completo na primeira linha, seu endereço na segunda, e o CEP e telefone na terceira.

3. Letra de música - Faça um programa que mostre na tela uma letra de música que você gosta (proibido letras do Justin Bieber).

4. Mensagem - Escreva uma mensagem para uma pessoa de quem goste. Implemente um programa que imprima essa mensagem, tire um print e mande pra essa pessoa. Diga que foi um vírus que algum hacker instalou em seu computador.

5. Ao site - Faça um programa que mostre na tela o que você deseja fazer usando seus conhecimentos de Perl.



6. Quadrado - Escrever um programa que mostre a seguinte figura:

XXXXX
X   X
X   X
X   X
XXXXX

7. Tabela de notas - Você foi contrato por uma escola pra fazer o sistema de boletim dos alunos. Como primeiro passo, escreva um programa que produza a seguinte saída:
ALUNO(A)          NOTA
=========         =====
ALINE              9.0  
MÁRIO              DEZ
SÉRGIO             4.5    
SHIRLEY            7.0

8. Letra grande - Elabore um programa para produzir na tela a letra P, de Perl Progressivo. Se fosse
‘L’, seria assim:
L
L
L
LLLLL

9. Menu - Elabore um programa que mostre o seguinte menu na tela:
Cadastro de Clientes
0 - Fim
1 - Inclui
2 - Altera
3 - Exclui
4 - Consulta
Opção: 

10. Pinheiro  - Implemente um programa que desenhe um "pinheiro" na tela, similar ao abaixo.
Enriqueça o desenho com outros caracteres, simulando enfeites.
       X
      XXX
     XXXXX
    XXXXXXX
   XXXXXXXXX
  XXXXXXXXXXX
 XXXXXXXXXXXXX
XXXXXXXXXXXXXXX
       XX
       XX
      XXXX

Escreva seus scripts nos comentários!
Ler Tutorial

Como Programar em Perl - Hello, world!

Agora que já te apresentamos a linguagem de programação Perl, vamos te mostrar o que é necessário fazer para, de fato, começar a programar em Perl.

Ou seja, vamos ver o que tem que faz, baixar, onde escrever, como rodar e tudo mais.

Como instalar o Perl

Primeiro passo é, obviamente, instalar o Perl.
Se você estiver usando um sistema Unix, como o Linux, ele já tem o Perl instalado por padrão.
Linux é, de longe, o melhor sistema operacional para programadores. Não é difícil, nem complexo, nem precisa ser um gênio ou hacker para usar o Linux.

Aliás, acho até mais fácil e intuitivo usar Linux.
Se quer levar a sério a profissão de programador, sugiro que instale alguma distribuição do Linux, como o Ubuntu e comece a aprender.

Lembre-se: todo mundo sabe usar Windows ou Mac, não tem nada demais nisso, até minha avó usa.
Mas saber usar Linux é um tremendo e interessante diferencial, vai te colocar automaticamente na frente de muuuuuitos programadores e profissionais de TI.

Mas vamos voltar ao Linux, rapidinho.
Abra o terminal de comando e digite: perl -v
Esse comando vai exibir a versão do seu Perl.

Para quem usa outra plataforma, como Windows, acesse o site oficial da linguagem:
https://www.perl.org/

Depois vá em download and get started.
Escolha sua plataforma (Windows, Linux...)

Se for Windows, provavelmente vai ter duas opções: ActiveState Perl e Strawberry.
Escolha a versão Strawberry.

Baixe o executável, aguarde o download, rode como administrador e faça a instalação do Perl.

Como Programar o Primeiro Script em Perl

Abra um editor de textos, pode ser o bloco de notas.

Se preferir, até sugerimos usar algum do tipo Notepad++ ou Sublime, pois vão deixar seu código melhor formatado, organizado, coloridinho e tal, uma belezura só.

Digite o simples comando:

print "Hello, world \n";

Agora salve seu arquivo com o nome: hello.pl
É muito importante ter a extensão pl, de Perl, ok?

Cuidado que as vezes o bloco de notas pode querer salvar como: hello.pl.txt
Não deixe isso acontecer.

Sugerimos salvar na pasta: C:\perl
Logo, o endereço do seu script será: C:\perl\hello.pl

Como rodar um script em Perl

Abra o terminal de comandos, o MS DOS ou shell do Linux.
Se estiver no Windows, digite:
cd C:\perl

No meu Linux, eu salvei em:
/home/user/perl

Agora que está na pasta/diretório do script, dê o comando pro Perl interpretar:
perl hello.pl

Se não funcionar teste: perl -w hello.pl no Windows

O resultado é esse:

Como programar em Perl


E prontinho, vai aparecer a mensagem na tela: Hello, world
Se conseguiu, você já é, oficialmente, um programador Perl, afinal, já fez e rodou seu primeiro script.

A linha hash-bang no Linux

Se estiver usando um sistema Unix, como Linux ou Mac, pode ser interessante tornar seu script Perl em um executável.

Vamos lá, primeiro torne seu script hello.pl em um executável:
chmod +x hello.pl

Agora rode ele:
./hello.pl

E veja que vai ter um erro.
Isso ocorre porque o terminal vai tentar ler e interpretar o conteúdo, e vai usar (geralmente) o bash pra interpretar esses comandos.

Mas não queremos que o shell interprete isso, e sim o Perl.
Para isso, usamos na primeiríssima linha de código Perl, o comando de hash-bang, veja como fica nosso código:

#!/usr/bin/perl
print "Hello, world!\n";

Adicionamos ao script o código: #!/usr/bin/perl (chamado hash-bang)
Pronto. A primeira linha diz ao interpretador do shell que queremos que o Perl interprete o script!
Agora tente rodar e veja que vai sair a mensagem "Hello world!" lindíssima na tela do terminal de comando.
Ler Tutorial

A linguagem de Programação Perl - O que é? Para que serve? Como funciona?

Neste tutorial inicial de nosso Curso de Perl online e grátis, vamos te falar um pouco sobre a história do Perl, como surgiu, com qual propósito, o que ele é de fato, para que serve e onde é usado, além de outras informações.
Como programar em Perl

História do Perl

A linguagem de programação Perl foi desenvolvido por um camarada chamado Larry Wall (uma verdadeira lenda da internet), enquanto trabalhava em um laboratório da NASA. A primeira versão foi no final de 1987. Logo, é uma linguagem bem madura e ainda muito usada, veio pra ficar.

Perl foi escrito na linguagem C.

O propósito inicial é curioso, o Perl foi concebido como uma espécie de cola (Internet glue), para unir diversas ferramentas de diversas linguagens e tecnologias diferentes, usadas por Larry e seus colegas. Ou seja, Perl nasceu como um 'quebra-galho', originalmente.

Embora tenha sido criada há décadas, seu desenvolvimento continua a pleno vapor, sempre melhorando e evoluindo, com a ajuda de milhares de pessoas ao redor do planeta contribuindo de livre e espontânea vontade, visto que ela é totalmente grátis e livre.

Nós vamos trabalhar aqui com a versão mais recente, o Perl 5.

O nome Perl veio das iniciais:
Practical Extraction and Report Language

Ou seja: "Extração prática e linguagem de relatório"

Por que aprender a programar em Perl ?

Existem trocentas linguagens de programação por aí, mas por que estudar e programar em Perl?
Quais as vantagens? Vale a pena ?

Antes de mais nada, devemos deixar claro que Perl é uma linguagem bem simples, direta e sem rodeios, bem fácil de aprender e absurdamente flexível.

O foco dela é o entendimento humano, na hora de criar o código. Diferente de outras linguagens, o foco não é na máquina, e sim no programador.

Vale destacar que ela é totalmente gratuita e livre. Livre pra modificar, distribuir

Perl é multi-plataforma, ou seja, os scripts rodam tanto em sistemas Unix (como Linux), como Mac e Windows, e a portabilidade é bem interessante.

É uma linguagem muito utilizada para se trabalhar com textos, através das expressões regulares (que estudaremos bem em detalhes, futuramente), sendo a extração de dados e informações o seu ponto forte.

Onde Perl é usado ?

Administradores de sistemas e redes simplesmente amam Perl, ele é uma tremenda mão na roda.
Com bem pouco código, é possível gerenciar uma rede de computadores de maneira bem prática e simples.

Perl também é muito usado para programação CGI, na geração dinâmicas de páginas da internet. Tem Perl em todo buraco e canto da Internet, pode acreditar.

Seu foco, porém, a manipulação de dados e informações dos mais diversos tipos, principalmente textual. Veremos que com o Perl é possível fazer coisas milagrosas, mexer em milhões de coisas com bem pouco código e de uma maneira bem fácil. Isso é muito importante ao lidar com arquivos do Linux por exemplo, ou com registros do Windows.

Linguagem e Programação de Computadores

Antes de entrarmos em detalhes no estudo da linguagem Perl, vamos dar uma pincelada sobre alguns assuntos importantes.

Ao longo de nosso curso de Perl, iremos escrever códigos, que nada mais são que comandos específicos para a máquina fazer o que quisermos.

Obviamente, ela não entende nossa linguagem nem a linguagem Perl.
Como assim?

Você já deve ter ouvido falar que em computação é tudo 0 e 1, e de fato é (na verdade tem a ver com voltagem). Essa é a única 'linguagem' que a máquina, o hardware entende.

Então o que vamos fazer é escrever código que humano entende (o chamado código fonte) e usar algum programinha pra traduzir isso pra linguagem de máquina, os 0 e 1. Esse processo, bem resumidamente, é a compilação ou também a interpretação, e geralmente resulta em um arquivo executável, como os .exe do Windows

Quando fazemos o processo de compilação, como na linguagem C, o compilador e outras ferramentas transformam nosso arquivo de texto com os comandos de alguma linguagem de programação (o chamado código-fonte) em código de máquina, para ela entender. Depois disso, basta rodarmos o executável, uma vez que foi compilado e criado, não precisamos repetir esse processo.

Já nas linguagens interpretadas, é necessário que um programa chamado interpretador sempre venha interceder por nossos benditos códigos. Nesse tipo de processo, o perl (p minúsculo, é um program), por exemplo, vai interpretar e rodar comando por comando de seu script (texto com código).

Nossos programas, ou mais comumente chamados scripts, em Perl, nada mais são que arquivos de textos, puros e simples. Texto mesmo, como um feito no bloco de notas.
A linguagem Perl é tão incrível, que com menos de 30 linhas de código você já faz coisas incríveis e complexas, escrevendo bem pouco e de maneira bem simples.

Agora que entendemos um pouco o que acontece por trás dos panos, vamos botar a mão na massa e escrever código em Perl de verdade, e vamos ver nossos scripts rodarem.
Ler Tutorial

Arrays (vetores) em Assembly - A diretiva TIMES

Neste tutorial de nosso Curso de Assembly, iremos continuar falando sobre a alocação de memória.

No caso, falaremos de alocação de blocos contínuos de memória, popularmente conhecidos como vetores (C, C++) ou arrays (Java).


Lembramos que vetores e arrays em Assembly são um vasto conteúdo, há uma série de possibilidades e conceitos por trás desta ideia, e ainda veremos muito sobre o assunto em nosso curso.

Porém, este tutorial está na seção básica e se destina a apresentar as ideias iniciais, alocação e inicialização de elementos de um vetor.



Array ou Vetor em Assembly

No tutorial passado de nosso curso falamos sobre as diretivas DEFINE e RES para alocar e reservar memória, e é de vital importância que você tenha estudado, entendido e com o assunto fresco em mente para que continuemos nosso curso, pois iremos continuar falando sobre alocar memória em Assembly.



Naquele artigo mostramos como declarar variáveis, dando um nome para elas e definindo o tanto de bytes que iremos separar em memória somente para aquelas variáveis, através de comandos como DB e DW.



Mas se notar bem, alocamos alguns espaços, manualmente.

E se for necessário alocar mil bytes diferentes, para armazenar números quando você for projetar o hardware de um microondas?

Um sistema como um relógio digital é complexo e pode usar dezenas de milhares de bytes facilmente, e como os recursos são poucos, é necessário usar a linguagem Assembly.



E é claro que você não vai manusear cada byte desses (embora programadores Assembly sejam conhecidos por serem escovadores de bits), e é para isso que existem os arrays, também conhecidos por vetores.



Um vetor, ou array, nada mais é que um bloco enorme de bytes, onde cada bloco é usado como uma variável, digamos assim, pois trabalhamos diretamente com bytes de memória, não importa se seja pra um inteiro, caractere ou booleano, pois essas ideias são de linguagens de alto nível, que abstraem diversos conceitos do que realmente ocorre por debaixo dos panos.



Para nós, vetor ou array em Assembly é um bloco de bytes, geralmente grande, para que possamos manipular uma quantidade maior de informações de uma maneira bem mais simples, óbvia e lógica.

No decorrer de nosso curso nos depararemos diversas vezes com arrays.































A diretiva TIMES: Como declarar e inicializar um vetor/array em Assembly

Para alocarmos memória usamos a diretiva define, mais conhecida pelas abreviações DW, DD, DQ etc, e principalmente pela DB (define byte).



Para alocar um bloco de vários bytes ainda utilizaremos a define, mas precisamos dizer quantas vezes esta alocação deve ocorrer.



Para dizermos o tanto de vezes (de blocos de bytes) que queremos alocar, vamos usar a diretiva TIMES (que pode ser traduzida como vezes . 3 times -> 3 vezes, 4 times-> 4 vezes).

Em seguida, devemos dizer o número de vezes que a define vai se repetir.



Após nomear, usar a TIMES, dizer o tanto de vezes que a alocação de bytes deve ser feita, devemos obviamente dizer quantos bytes vão ser alocados por vez.

E como sabemos, para alocar bytes usamos os comandos DB, DW, DD, DQ e DT.



E por fim, devemos dar um valor inicial para esses bytes do bloco de memória.

Você pode alocar 1 milhão de blocos de DT (cada DT aloca 10 bytes), e inicializar cada um deles com um valor numérico, de forma totalmente automática.



Assim, a sintaxe geral para se declarar um vetor/array em Assembly é:

nomeDoBloco       TIMES    numeroDeVezes    diretivaDEFINE    valorInicial


Vamos criar um array de nome "vetor", cada elemento do vetor vai ser alocado através de um DB, esse vetor terá 10 elementos (então vamos repetir 10 vezes a alocação DB) e vamos inicializar todos os elementos de nosso array com valor 0:

vetor      TIMES    10    DB    0


Agora vamos declarar um vetor de nome "array", ele será composto de 20 elementos do tipo word (2 bytes cada), e será inicializado com o valor hexadecimal FFH:

array       TIMES    20    DW    FFH


Espaços contíguos de memória Assembly

Um fato interessante que ocorre na linguagem de programação Assembly é que, ao reservar e alocar espaços de memória, isso é geralmente feito de modo que os blocos de memória sejam contíguos, ou seja, vizinhos.



Por exemplo, vamos supor que nossa variável "elemento1' ocupe um byte, vamos dizer que na posição "x" de memória:

elemento1      DB   00H


Se formos, em seguida, alocar a variável "elemento2" que é do tipo e word e ocupa 2 bytes, ela vai estar na posição "x+1" de memória, pois na posição "x" está o "elemento1" e ele ocupa 1 byte:



A próxima variável que declararmos vai estar na posição "x+3", pois o local "x" é ocupado por "elemento1" e os dois bytes seguintes é ocupado por "elemento2", concorda?



Vamos fazer a seguinte declaração:

elemento1      DB   00H
elemento2      DW   01H
vetor1         TIMES   10   DB   0
vetor2         TIMES   20   DW   0
elemento3      DD   0


Note que que o "vetor1" ocupa 10x1=10 bytes, pois ele aloca 10 elementos do tipo byte (DB).

E como dissemos, o "vetor1" vai inicial no local de memória "x+3", como ele ocupa 10 bytes, o próximo vetor vai se iniciar na posição "x+3+10", ou seja, "vetor2" começa na posição "x+13", ok?



Agora vamos analisar "vetor2", ele declara um bloco de memória de 20 elementos do tipo WORD, onde cada um destes ocupada 2 bytes. Então "vetor2" ocupada 20x2=40 bytes.



Entendeu mesmo?

Então em que posição de memória vai estar localizada a variável "elemento3"?

A resposta está em branco ao lado (seleciona o local com o mouse): x+13+40 = x+53



E caso deseje declarar outra variável abaixo de "elemento3", em que posição de memória esta variável vai começar? (lembre-se que "elemento3" ocupa 4 bytes): x+53+4 = x+57


Ler Tutorial

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


Ler Tutorial

Define - Como alocar memória Assembly - RES, como reservar memória

Se você estudou somente linguagens de altíssimo nível, como as de linguagens de script, com certeza nunca se preocupou em alocar memória, pois é tudo feito automaticamente por debaixo dos panos.

Se estudou linguagens como C ou Java, você alocava espaço na memória ao declarar variáveis e estruturas (em C é possível ainda, a alocação dinâmica de memória).

Nesse tutorial de nosso curso de Assembly, vamos aprender como reservar espaço em disco em Assembly, ver quais as diferenças e peculiaridades nessa linguagem de baixo nível.


Alocação de memória em programação

Em outras linguagens de programação, para declarar variáveis precisávamos definir o tipo antes.

Por exemplo, em C ou C++, escrevíamos 'int' para inteiros, 'float' ou 'double' para decimais, 'char' para caracteres, dentre outros tipos.

Ao fazermos isso, sem saber (diferente do Assembly, em que vemos claramente como as coisas são feitas), estamos dizendo muito mais do que simplesmente a alocação de memória em si.

O resultado de uma operação entre um inteiro e um decimal não é totalmente previsível, depende da variável em que vamos armazenar, da linguagem e de outras regra específicas.

Quando declaramos uma variável do tipo double ou float, já fica subentendido que haverá uma vírgula (ou ponto), representado sua parte decimal. Além disso, há divisões no espaço alocado de memória, para armazenar a parte decimal e a parte não decimal.

Enfim, acontece muito mais do que simplesmente reservar um espaço de memória. Muitas rotinas úteis, que facilitam a vida de programador acontecem por debaixo dos panos.





























Alocação de memória em Assembly - A diretiva define

Obviamente, em Assembly as coisas são um pouco diferente.

Essas coisas que atuam sem o conhecimento do programador simplesmente não existem, e o profissional que programa em Assembly ficará a cargo de tudo.

Em Assembly, você realmente irá alocar espaço em memória. E somente isso.

Por exemplo, usamos o mnemônico ADD para adicionar um número a outro. Mas ele não vai simplesmente adicionar todos e quais números automaticamente como costumamos fazer em outras linguagens.

Se o resultado der mais de dois dígitos, por exemplo, você terá que fazer uma rotina para exibir esses dois dígitos (sabe quando você soma no papel, fazendo continha e o valor da soma dá mais que 9, aí 'vai 1' ou 'sobe 1' ? é algo parecido) ; ao somar, ter cuidado para saber se somou o caractere '1' ou realmente o número 1. Case seja caractere, ou queira exibir, terá que fazer alterações, e por aí vai.

Como enfatizamos, Assembly é em baixo nível.

Trabalhamos com bits e bytes. E nesse nível, as coisas não vem prontas.

O programador Assembly é que o tem o poder e responsabilidade de absolutamente tudo. Por isso, ao alocar memória, temos que definir o número de bytes que vamos usar.

Vamos usar as seguintes variações da diretiva define: DB, DW, DD, DQ e DT.

Eles significam e alocam determinados número de bytes, veja:



DB = Define Byte            -> aloca 1 byte

DW = Define Word           -> aloca 2 bytes

DD = Define Doubleword  -> aloca 4 bytes

DQ = Define Quadword    -> aloca  8 bytes

DT = Define Ten              -> aloca 10 bytes



Sabendo disso, poderemos agora mostrar como é a sintaxe de uma instrução em Assembly para alocar memória:

Nome_da_Variavel diretiva_define valor



Por exemplo, para alocar espaço para o caractere 'A', fazemos:

letra1 DB 'A'



Lembramos que, na verdade, embora tenhamos escrito o caractere 'A', tudo são números.

Então, como na tabela ASCII o valor de 'A', em hexadecimal é 41, poderíamos ter feito:

letra1 DB 41H



Colocamos a letra H ao final do número para dizer que estamos representando em Hexadecimal.

Se fossemos colocar em binário, temos que colocar a letra B ao final:

letra1 DB 01000001B



Para saber mais sobre os caracteres em programação, consulte nosso artigo do site C Progressivo, que também mostra a tabela ASCII:

http://www.cprogressivo.net/2012/12/O-tipo-char-como-escrever-textos-na-linguagem-C.html



Um pouco de matemática

Em Assembly, trabalhamos sempre com bytes, onde um byte equivale a 8 bites.

Cada bit desse pode ser 0 ou 1, então podemos representar até: 2^8 = 256 caracteres com um byte.



Em Hexadecimal, podemos representar esses 256 caracteres usando os números 00H até FFH.

Ou seja, 41H caberia em um byte, pois é menor que FFH.

Agora 2112H só caberia em dois bytes, onde um armazenaríamos o byte 12H e no outro o byte 21H.



Vamos armazenar uma senha na variável 'senha', ela conterá 4 dígitos decimais: 1234

Esse número, em hexadecimal equivalem a 4660H.

Precisamos, então, definir dois bytes, ou uma palavra (word). Um byte armazena o 60H e o outro armazena o 46H.

Para alocar memória para essa senha, faríamos:

senha DW 466H



Outras maneiras de alocar memória em Assembly

E se quiséssemos alocar uma palavra, como 'curso', por exemplo?

Poderíamos alocar letra por letra:

letra1 DB 'c'

letra2 DB 'u'

letra3 DB 'r'

letra4 DB 's'

letra5 DB 'o'



Porém, seria muito trabalhoso, e há maneira mais fáceis de se fazer isso.

Em vez de ter que dar um nome para cada letra (isso não faz o menor sentido!), poderíamos dar um nome só para o conjunto de letras:

curso DB 'c'

DB 'u'

  DB 'r'

  DB 's'

  DB 'o'



E sempre que usarmos a variável curso, o Assembly saberá que se trata de conjunto de caracteres.

Porém, esse exemplo, assim como o anterior, tem mais caráter de informação para você, leitor de nosso curso Assembly Progressivo.



A maneira mais prática e utilizada para armazenar uma string, é utilizando a define DB e escrevendo uma string (que nada mais é que um texto, um conjunto de caracteres).

O Assembly irá alocar, automaticamente, todos os caracteres, como se tivéssemos feito o exemplo passado.



No exemplo do "Hello, world" em Assembly, nosso primeiro programa, fizemos isso:

helloWorld DB 'Curso Assembly Progressivo: online, gratis e completo'



Bem mais prático, não?



Reservando memória em Assembly

Até agora, usando a diretiva define e suas variações (DB, DW, DD, DQ e DT), alocamos memória em Assembly para armazenar e INICIALIZAR variáveis! Porém, nem sempre vamos inicializar, apenas queremos alocar.

Isso é comum para armazenar variáveis cujos valores serão fornecidos posteriormente, pelo seu programa, pelo usuário ou um dispositivo de entrada e saída.



Para reservar memória, usamos a diretiva RES, ao mesmo molde da diretiva DEFINE:

RESB = Reserve Byte             -> reserva 1 byte

RESW = Reserve Word            -> reserva 2 bytes

RESD = Reserve Doubleword   -> reserva 4 bytes

RESQ = Reserve Quadword     -> reserva 8 bytes

REST = Reserve Ten               -> reserva 10 bytes



A sintaxe é um pouco diferente da DEFINE, já que não vamos inicializar.

Assim, em vez de valor inicial, temos que dizer quanto de espaço queremos reservar, dependendo da diretiva que usamos.

Sintaxe para reservar memória:

nome_da_variavel diretiva_res numero_de_unidades



Por exemplo:

variavel1 RESB 1 ; nesse caso, reservamos apenas 1 byte

variavel2 RESB 2 ; aqui, reservamos 2 bytes

variavel3 RESW 3 ; 3 palavras são reservadas, o que nos dá 3*2 = 6 bytes

variavel4 REST 10 ; reservamos 10 unidades, de 10 bytes cada
Ler Tutorial

Tutoriais de Programação