Aula 7 - Paradigmas de Linguagens de Programação

Prévia do material em texto

Paradigmas de linguagens de programação
Aula 7: Expressões
Apresentação
Veri�camos nas aulas anteriores a importância de as linguagens de programação (LPs) implementarem uma gama de
tipos de dados. Nesta aula, entenderemos os conceitos envolvidos na construção e na execução de expressões em LPs.
Esse tema está relacionado aos tipos de dados, já que as expressões possuem operandos que são de determinado tipo, e
aos operadores, que restringem as operações conforme tipos de dados.
Apresentaremos também os conceitos de expressões simples e compostas, além dos respectivos operadores e dos tipos
de dados possíveis para os operandos. Por �m, anotaremos ainda os eventuais efeitos colaterais no uso de expressões,
apontando os conceitos inerentes às compostas.
Objetivos
De�nir os conceitos e a classi�cação das expressões;
Listar tipos de expressões simples;
Ordenar as expressões compostas.
Atenção! Aqui existe uma videoaula, acesso pelo conteúdo online
Conceitos e tipos de expressões
Expressões aritméticas foram a motivação para o desenvolvimento da primeira LP. Implementadas nessas linguagens, as
expressões precisam ser avaliadas, produzindo um valor como resultado disso.
Temos então como elementos de uma expressão:
Clique nos botões para ver as informações.
Determinam os tipos de operações que podem ser realizados nas expressões.
Operadores 
Valores sobre os quais as operações são realizadas.
Tipos de dados dos operandos 
Valor produzido pela avaliação da expressão ao ser executada.
Tipo de resultado produzido 
As expressões podem ser classi�cadas em simples ou compostas conforme ilustra a �gura a seguir. Aquelas envolvem apenas
um operador; estas, mais de um:
 Figura 1: Tipos de expressões.
É importante que os programadores percebam a relevância do conhecimento das expressões suportadas por uma LP ao
estudarem ou iniciarem o seu uso. Elas garantem às linguagens um poder de processamento. O programador, portanto, deverá
estar familiarizado com a ordem de avaliação das expressões na respectiva LP de interesse.:
Sobre esse tema, as questões geralmente debatidas nos projetos de LP são:
Atenção! Aqui existe uma videoaula, acesso pelo conteúdo online
Tabela 1: Tipos de operadores.
Expressões simples
Tipos de operadores
Os operadores são determinantes para as expressões. A principal característica de um operador é a aridade, que denota o
número daqueles a serem requeridos para realizar a operação. Observe esta tabela:
Operador Aridade Operandos
Unário 1 1
Binário 2 2
Ternário 3 3
.... .... ....
.... .... ....
Eneários Variável Qualquer número
Os operadores podem ser prede�nidos pela própria LP ou criados pelos programadores por meio da especi�cação de funções
(procedimentos que retornam um valor). Entre os operadores prede�nidos nas linguagens, a maioria é do tipo unário ou binário
(predominante), sendo raro haver um com aridade superior.
Exemplo
Java, C e C++ implementam apenas um operador ternário (aridade 3) e nenhum de aridade superior.
Ao de�nirem as funções, os programadores poderão criar operadores de qualquer aridade estabelecidos na lista de parâmetros
da função. Todavia, cabe um alerta: aridade elevada afeta a legibilidade e a redigibilidade da LP.
No que tange aos operadores eneários, poucas LPs implementam.
Exemplo
Java e Pascal não implementam. Nas linguagens C e C++, os eneários podem sê-lo pelo uso de funções com o número de
parâmetros variável, mas não como operadores prede�nidos pelas LPs.
Os operadores poderão ser usados se três notações diferentes forem levadas em consideração. Observe esta tabela:
Tabela 2: Notação dos operadores.
Tabela 3: Notação dos operadores.
Notação Características (exemplo em C)
Prefixada Operador vem antes dos operandos:
a = !b
Infixada Operador entre os operandos:
a = a + b
Pós-fixada Operador bem após os operandos:
a = b++
Na maioria das LPs, os operadores binários são usados na notação in�xada; os demais, na pré-�xada.
Exemplo
C e C++ usam as seguintes notações para seus operadores:
Operadores (aridade) Notação usada
Maioria dos unários (!, sizeof) Prefixada
Binários e ternários Infixada
Alguns unários (++, --) Pós-fixada
Tipos de expressões
As expressões são classi�cadas de acordo com:
Tabela 4: Tipos de expressões.
O quadro a seguir apresenta os 11 principais tipos de expressões implementados pelas LPs:
1. Agregação 2. Aritméticas
3. Relacionais 4. Lógicas (booleanas) 6. Binárias (bits)
6. Condicionais 7. Chamadas de funções 8. Efeitos colaterais
9. Referenciamento 10. Categóricas
Vamos abordar cada tipo de expressão deste quadro na sequência:
Clique nos botões para ver as informações.
É usada para construir um valor a partir dos componentes. Operador de agregação: marcadores de início e �m da
expressão.
Exemplo:
C:
Int c[ ] = {a,b,c};
Struct data d = {28,02,2012};
Char * X = { , , , };
Int b[6]= {8};
Char *y = “abc”
Avaliando as cinco linhas de expressões acima, podemos considerar:
Após o sinal de igualdade, aparece o que chamados de subexpressões;
Nas linhas 1 a 4, os operadores de agregação são denotados pelas { (abre) e } (fecha) chaves;
As expressões das linhas 3 e 5 são equivalentes.
As subexpressões podem ser:
Estáticas: Se forem avaliadas em tempo de compilação;
Dinâmicas: Se o forem em tempo de execução.
Exemplo:
Trecho de código de uma função na LP C:
Void f(int i) {
Int a[ ] = {3+5,2,16/4}; // subexpressões estáticas
Int b[ ] = {3*i, 4*i, 5*i}; // subexpressões dinâmicas
Int c[ ] = {i+2, 3+4, 2i}; // subexpressões estáticas e dinâmicas
}
Avaliando este trecho de código, é possível observar que:
Na linha 1, temos três operações aritméticas simples contidas na subexpressão (após a igualdade) que serão
resolvidas em tempo de compilação, pois os valores expressos são constantes;
Na linha 2, há três operações expressas com base na variável i, cujo valor somente será conhecido em tempo de
execução;
Na linha 3, duas operações estão expressas com base na variável i (1a e 3a). Elas somente poderão ser resolvidas
em tempo de execução quando soubermos o valor de i para resolver a expressão.
Vejamos mais um exemplo a seguir:
Agregação 
a b c0
Exemplo:
A linguagem Ada possui recursos para não apenas inicializar o vetor com base em expressões agregadas, mas também
permitir o uso de expressões agregadas para a atribuição de valores:
Type
Data is record
Dia: integer range 1..31;
Mes: integer range 1..12;
Ano: integer range 1900..2100;
End record;
Aniversario: Data;
Data_admissao: Data := (28,9,1989);
Aniversario := (28,1,2001);
Data_admissao := (dia => 5, ano =>1980, mes =>2);
Vejamos algumas considerações sobre este trecho de código:
Os operadores de agregação são denotados pelos ( (abre) e) (fecha) parêntesis;
Usam-se expressões agregadas para inicializar Data_admissao e atribuir valores às variáveis aniversario e
data_admissão;
Na última e antepenúltima linha, são usadas duas formas de atribuir valores a uma variável do tipo registro: esta usa
a correspondência posicional entre os valores do agregado e os campos do registro, enquanto aquela utiliza a
correspondência nominal entre os valores e os campos, mas não necessariamente na mesma ordem de de�nição do
tipo (cláusula TYPE).
São as mais conhecidas pela proximidade com as expressões matemáticas, pois geram valores numéricos: inteiro,
decimal e ponto �utuante.
Exemplo:
Operadores aritméticos em C: soma (+), subtração (-), multiplicação (*) e divisão (/ ou %).
As operações de adição e subtração podem ser usadas como operadores unários e binários. A subtração (-) (unária)
provoca a inversão da sinalização do operando, enquanto a adição (+) (unária) não gera qualquer alteração no operando.
O operador / denota a divisão entre os inteiros e o ponto �utuante conforme os tipos de dados dos operandos, enquanto o
% faz isso com o resto da divisão entre os operandos do tipo inteiro.
Exemplo:
A expressão 7 % 2 terá 1 como resultado.
Considere este trecho de código escrito em C:
�oatnumreal;
Int numint=9;
numreal = numint/6;
numreal = numint/6.0
Teremos ao �nal do trecho de código acima:
A variável numreal, na penúltima linha, terá este valor resultante: 9/6 = 1;
A variável numreal, na última linha, será de 9/6.0 = 1,5.
Expressões aritméticas 
Como o próprio nome indica, as expressões relacionais têm por objetivo relacionar (comparar) os valores de seus
operandos.
As expressões relacionais possuem uma restrição: os operadores, à exceção daqueles de igualdade e desigualdade,
devem ser do mesmo tipo para efeitos de comparação.
Em geral, elas retornam um valor lógico ou booleano: verdadeiro (true) ou falso (false). Para as LPs que não implementam
o tipo booleano, haverá um valor que indica verdadeiro ou falso (em geral, 0 e 1).
Exemplo:
Em Pascal, temos os seguintes operadores relacionais: = (igual), <> (diferente), > (maior), < (menor),>= (maior ou igual) e
<= (menor ou igual).
Já C e Java apresentam == (igual), != (diferente), >, <,>=, >=, enquanto Ada tem = (igual), /= (diferente), > (maior), <
(menor),>= (maior ou igual) e <= (menor ou igual).
Expressões relacionais 
Realizam as operações da álgebra booleana (cujo nome foi escolhido em homenagem ao matemático George Boole). Os
operandos são valores do tipo booleano ou equivalente (linguagem que não implementa valores booleanos). O resultado
será um valor booleano ou equivalente.
A maioria das LPs implementa os seguintes operadores lógicos:
Operadores binários: E – conjunção / OU – disjunção;
Operador unário: NAO – “não lógico”.
As expressões booleanas consideram a tabela a seguir:
Tabela 5: Tabela Verdade.
Exemplo:
Para entender as expressões lógicas na linguagem Pascal, observe o trecho de código a seguir:
Var
Log1, Log2, Log3: boolean;
Begin
Log1:=False;
Log2:=True;
Log3:= Log1 and Log2; // False E True = False
If Log1 or Log2 = true Then writeln (‘oi’);
End.
Expressões lógicas (booleanas) 
Operador1 Operando Operador2 Resultado
Verdade E Verdade Verdade
Verdade E Falso Falso
Falso E Falso Falso
Verdade OU Verdade Verdade
Verdade OU Falso Verdade
Falso OU Falso Falso
Falso NÃO Verdade
Verdade NÃO Falso
Log3 recebe o valor False (linha 3, após begin). A expressão da linha 4 associada à condição IF, Log1 or Log2, terá como
resultado o valor lógico TRUE. Será exibida a cadeia “oi” pelo comando writeln (mostrando no dispositivo padrão de saída:
monitor).
Na próxima tabela, exibiremos os operadores lógicos em algumas LPs. Observe que Ada é a linguagem mais poderosa em
termos de operadores lógicos (booleanos):
Tabela 6: Operadores lógicos em algumas LPs.
FORTRAN 77 Fortran 90 C Ada
.AND. and && and
.OR. or || or
.NOT. not ! not
xor
FORTRAN 77 Fortran 90 ADA C Java
.AND. and and && &&
.OR. or or || ||
.NOT. not not ! !
Algumas LPs, como C, implementam este tipo de expressão por meio de operadores que permitem manipular bits. O
objetivo é expressar programas mais e�cientes e com menor consumo de memória.
C dispõe de cinco operadores binários:
& - conjunção binária (AND);
| - disjunção inclusiva (OR);
^ - disjunção exclusiva (XOR);
<< - deslocamento (shift) à esquerda;
>> - deslocamento(shift) à direita.
A linguagem C dispõe ainda de um operador unário para implementar complemento a um (NOT). Trata-se do operador ~.
Expressões binárias 
Compostas por duas ou mais subexpressões, elas retornam como resultado o valor de uma delas. Sua �nalidade é avaliar
expressões condicionalmente conforme o contexto.
Exemplo:
Observe este trecho de código na linguagem ML:
val c = If a > b then a-3 else b+5
val k = case of
1 => If j>5 then j-8 else j+5
2 => 2*j
3 => 3*j
_ => j
Na linha 1, podemos destacar o seguinte: caso a subexpressão a>b seja verdadeira, o valor retornado da expressão será o
da subexpressão a-3; caso contrário, será b+5.
Na linha seguinte, a estrutura CASE possui cinco subexpressões. Se o valor de i for:
1: O resultado da expressão condicional corresponderá ao resultado;
2: Resultado será 2*j;
3: Resultado será 3*j;
Qualquer outro valor: A expressão condicional retorna o valor de j.
Como Pascal e Ada não implementam expressões condicionais, os programadores simulam tais expressões usando
comandos condicionais. Conheçamos agora um exemplo para a linguagem Ada:
Exemplo:
Eis uma linha de código em Ada:
If x > y then max:=x; else max >=y;
Vejamos mais um exemplo – desta vez, para Java:
Exemplo:
Este trecho de código em Java exempli�ca a implementação de expressões condicionais:
max = x>y ? x : y;
par = z % 2==0 ? true : false;
Na primeira linha, a expressão condicional retorna o maior valor entre x e y que será atribuído à variável max; na seguinte,
ela avalia se z é par ou não.
Expressões condicionais 
Também são consideradas expressões as chamadas de função criadas pelo programador. Seu operador é representado
pelo nome da função, enquanto os operandos o são pelos parâmetros.
Considere a chamada a função func(a), em que:
• func é o operador;
• a é o operando.
Conclui-se que o resultado retornado por func(a) será o mesmo da expressão. Funções permitem a criação de expressões
de qualquer aridade dependendo da lista de parâmetros.
Exemplo:
A função funca(p1,....,pn), retorna a aridade n.
Chamada de função 
Em linguagens imperativas, há expressões que causam efeitos colaterais.
Exemplo:
Avalie o incremento de variável ilustrado neste comando C:
num = 3.5 ++num2;
O objetivo desta expressão é calcular o valor a ser atribuído à variável num; no entanto, ela produz um efeito colateral ao
alterar o valor de num2.
Efeitos colaterais afetam a legibilidade e entendimento do código. Tanto as funções prede�nidas como as de�nidas
pelo programador podem produzir um efeito colateral à medida que atualizam os valores de variáveis globais ou quando
há uma passagem de parâmetros por referência (que, na verdade, passa para a função o endereço de memória da
variável, possibilitando a alteração de seu valor ao sair dela).
Expressões com efeitos colaterais 
São usadas para:
• Acessar o conteúdo de variáveis e constantes por referenciamento direto;
• Retornar uma referência (em geral, um endereço de alocação em memória) para variáveis e constantes.
A forma mais simples é o referenciamento direto a variáveis e constantes.
Exemplo:
Acompanhe este trecho de código em C:
const �oat pi = 3.1416;
int raio = 3;
�oat perímetro = 2*pi*raio;
Outro uso para a expressão de referenciamento é o acesso a estruturas de dados compostas:
Para acessar o valor de um elemento do vetor: Operando = vetor e índice do elemento;
vet [ind-1] = vet [ind]: Atribui à posição do vetor indexada por ind-1 o valor de ind do vetor.
* num = * num + 3: Lado esquerdo: Endereço da variável apontada por num; lado direito: Conteúdo de num.
Exemplo:
Veja este código em C:
• registro.ano = registro. Ano + 1;
• sem ->dia = sem ->dia + 1;
• t = & m;
Observe também a tabela a seguir com os operadores de referenciamento em C:
Tabela 7: Tabela de referenciamento em C.
Expressões de referenciamento 
Operador Significado
[] Acesso a valor ou retorno de referência de elemento de vetor.
* Acesso a valor ou retorno de referência de variável ou constante apontado por ponteiro e de elemento da estrutura.
-> Acesso a valor ou retorno de referência de elemento de estrutura apontado por ponteiro.
& Retorno de referência a qualquer tipo de variável ou constante.
Realizam operações sobre tipos de dados, servindo para extrair informação acerca de variáveis e constantes ou para
converter valores entre tipos.
C dispõe de dois operadores com esse �m:
1. Sizeof: Obtém o tamanho (em bytes) do objeto ou do tipo dele conforme exempli�ca esta linha de código:
�oat * p = (�oat ) malloc (10 * sizeof (�oat));
Sizeof descobre o tamanho do tipo �oat, enquanto Malloc aloca o espaço para 10 elementos deste tipo.
2. Operador de tipo (< tipo>): Na última linha do código a seguir, o valor do tipo inteiro int armazenado em num é
convertido para �oat:
�oat valor;
int num = 9, den= 5;
valor = (�oat) num/den;
Expressões categóricas 
 Fonte: Unsplash | Por: @markusspiske.
Expressões compostas
As expressões compostas envolvem duas ou mais operações a serem avaliadas. Para isso, deve-se considerar os conceitos de:
Precedência de operadores
Ela determina a ordem que os operadores devem ser considerados na avaliação de uma empresa. Isso �cará expresso da
maior para a menor precedência (importância) em tantos níveis quanto forem necessários.
Considere a expressão matemática X = A + B * C, sendo A =1, B=2 e c=3.
Questão básica que esclarece o conceito de precedência de operadores: iniciamos a avaliação da expressão da esquerda
para a direita ou desta para aquela?
A matemática de�niu uma hierarquia de importância dos operadores: multiplicação (*) e divisão (/) têm precedência sobre
soma (+) e subtração (-).
A expressão acima, portanto, terá como resultado X = 1 + 2 * 3 = 1 + 6 = 7. Ou seja, X = 7.
As LPs geralmente seguem essa convenção herdada da matemática, além de implementarem outras.
Saiba mais
Observe a precedência de operadores implementada pela linguagem Lua:
 Figura 2: Precedência de operadores em LUA.
Exemplo
Em Pascal, os operadores relacionais têm menor precedência que os lógicos. Para alterar a ordem de precedência, deve-se usar
parêntesis.
Os níveis de precedência típicos (boa parte das LP os seguem) são:
A tabela a seguir mostra a precedência de operadores em algumas LPs:
 Tabela 8: Preferência de operadores.
Associatividade de operadores
As regras de associatividade de operadores são usadas para determinar a precedência deles quando a linguagem não a de�ne
ou quando operadores adjacentes têm a mesma precedência na expressão.
Considere a expressão X = A – B + C – D. As operações retratadas são todas do mesmo nível de precedência (+ e -).
Neste caso, se não houver parêntesis (ou outro delimitador, conforme a LP), a ordem a prevalecer será a da matemática,
avaliando a expressão da esquerda para a direita (associatividade pela esquerda). Existem operadores que fazem isso pela
direita, de maneira análoga à do raciocínio anterior.
Exemplo
Exponenciação.
Ainda existem aquelas linguagens que não de�nem a associação para a exponenciação. Para isso, o uso de parêntesis (ou
outro delimitador da LP) é mandatório.
Na próxima tabela, é possível veri�car as de�nições de associatividade de operadores de algumas LPs:
 Tabela 9: Associatividade de operadores.
Precedência de operandos
A precedência de operandos avalia a ordem de avaliação deles.
Exemplo
C não determina tal ordem, �cando a cargo do compilador essa avaliação. A de um operando pode afetar ou não a avaliação de
outro. Java, por sua vez, determina que os operandos sejam avaliados da esquerda para a direita.
Tabela 10: Curto-circuito em avaliações de expressões.
Curto-circuito
Em uma avaliação curto-circuito de uma expressão, o resultado pode ser determinado sem haver a avaliação de todos os
operandos/operadores.
Considere a expressão aritmética: x = (8*a) + (b/12).
Se o valor da variável a for zero, não existe a necessidade de avaliar a segunda parte da expressão, a partir de + (b/12), pois x
sempre será zero.
Considere agora a expressão composta: logica = (a >= 0) and (b < 10).
Se a primeira expressão relacional (a>=0) for false, sendo o operador AND, ela jamais será verdade; assim, a expressão AND (b
< 10) não é avaliada.
Esta tabela destaca como Pascal, C, C++ e Java implementam a avaliação curto-circuito de expressões:
Pascal C, C++ e Java
Não usa curto-circuito Usam para operadores lógicos usuais (&&, ||). Mas também utilizam outros que não são curto-circuito (&, |)
Conversões de tipos em expressões
Muitas vezes, dependendo da LP e da lógica, a avaliação de uma expressão requer a conversão de tipos de dados. Existem dois
tipos de conversão:
Clique nos botões para ver as informações.
Converte-se de um tipo de maior grandeza/precisão para um de menor. O valor de destino não pode armazenar todos os
possíveis valores do tipo original.
Exemplo:
Converter de �oat para int é uma conversão de estreitamento. Este tipo de conversão nem sempre é seguro.
Estreitamento 
Converte para um tipo que pode incluir, senão todos os valores do tipo original, ao menos uma aproximação deles. Suas
conversões são quase sempre seguras, embora possam resultar em redução da precisão do dado.
Exemplo:
Converter de int para �oat é uma conversão de alargamento.
Além dessa classi�cação, uma conversão de tipos pode ser:
• Implícita: Ocorre uma conversão automática entre tipos para resolver uma expressão, como a coerção;
• Explícita: A LP dispõe de mecanismos denominados casts quando é solicitada pelo programador no código-fonte.
Exemplo:
Considere o trecho de código em Java no qual haverá uma conversão de int para �oat (no comando d = b*a), pois a é
inteiro.
Int a;
Float b,c,d;
.......
d = b*a;
Alargamento 
Comentário
Na maioria das LPs, os tipos numéricos têm coerção nas expressões usando conversões de alargamento. Em Ada, praticamente
não há coerção em suas expressões.
Atenção! Aqui existe uma videoaula, acesso pelo conteúdo online
Atividade
1. Sobre conceitos e tipos de expressões, avalie as assertivas a seguir:
I. As expressões são classi�cadas em simples e compostas.
II. As expressões compostas englobam subexpressões simples.
III. As LPs implementam as mesmas regras de precedência de operadores.
IV. Uma expressão possui sempre um operador e dois operandos.
Com base em sua análise, marque a opção que apresenta apenas as assertivas corretas:
a) I e II
b) II
c) I
d) II e IV
e) I, II, III e IV
2. Pense e responda:
Seria viável as LPs deixarem de implementar precedência e associatividade e os programadores usarem parêntesis sempre?
Enumere as vantagens e desvantagens disso, citando uma linguagem que adote tal mecanismo.
3. No que se refere exclusivamente às expressões compostas, avalie as assertivas a seguir:
I. Em uma avaliação curto-circuito de uma expressão, o resultado não pode ser determinado sem avaliar todos os
operandos/operadores.
II. Float para int constitui uma conversão de alargamento.
III. As regras de associatividade de operadores são usadas para determinar a precedência deles quando a LP, por exemplo, não
de�ne a precedência.
IV. Coerção é uma forma de conversão explícita por meio de um comando do programador.
Está correto apenas o que se a�rma em:
a) I
b) III
c) II e III
d) II e IV
e) IV
Notas
Título modal 1
Lorem Ipsum é simplesmente uma simulação de texto da indústria tipográ�ca e de impressos. Lorem Ipsum é simplesmente
uma simulação de texto da indústria tipográ�ca e de impressos. Lorem Ipsum é simplesmente uma simulação de texto da
indústria tipográ�ca e de impressos.
Título modal 1
Lorem Ipsum é simplesmente uma simulação de texto da indústria tipográ�ca e de impressos. Lorem Ipsum é simplesmente
uma simulação de texto da indústria tipográ�ca e de impressos. Lorem Ipsum é simplesmente uma simulação de texto da
indústria tipográ�ca e de impressos.
Referências
IERUSALIMSCHY, R.; FIGUEIREDO; L. H. de; CELES, W. Lua 5.2 reference manual. Disponível em:
http://www.lua.org/manual/5.2/manual.html#3.4.7. Acesso em: 28 ago. 2019.
SEBESTA, R. W. Conceitos de linguagem de programação. 11. ed. Porto Alegre: Bookman, 2018.
TUCKER, A. B. Programação: princípios e paradigmas. 2. ed. Porto Alegre: AMGH, 2010.
VAREJÃO, F. M. Linguagem de programação: conceitos e técnicas. Rio de Janeiro: Elsevier, 2004.
Próxima aula
Conceitos considerados pelas LPs na construção de comandos (sequenciais, decisão, repetição e outros);
Utilização do conceito de modularização.
Explore mais
Conheça os operadores relacionais;
https://dicasdeprogramacao.com.br/operadores-relacionais/
Usando expressões matemáticas em JS;
https://pt.khanacademy.org/computing/computer-programming/programming/resizing-with-variables/a/using-math-
expressions-in-js
Precedência e associatividade de operadora de linguagem C;
http://www.inf.ufpr.br/danielw/grad/ci067/20092/op-prec.htmlLinguagem C – operadores;
https://juliobattisti.com.br/tutoriais/katiaduarte/cbasico002.asp
Qual linguagem de programação devo aprender?
https://devsamurai.com.br/qual-linguagem-de-programacao-aprender-em-2018/
javascript:void(0);
javascript:void(0);
javascript:void(0);
javascript:void(0);
javascript:void(0);