As Diferenças entre as Linguagens Compiladas e Interpretadas
Olá, mundo! Tudo bem?
Hoje temos inúmeras linguagens para satisfazer uma série de funções distintas de toda ordem, nos primórdios da Internet, tínhamos pouquíssimas páginas com conteúdo dinâmico, quando eram, baseavam-se em algo escrito em C, quem é mais antigo lembrará do termo CGI, cujo o significado é Common Gateway Interface, que nada mais era que uma espécie de API que permitia interpretar programas compilados e disponibilizar em formato HTML.
Introdução
Aqui só para demonstrar, iríamos ter que salvar este arquivo olamundo.c na pasta /var/www/cgi-bin do nosso Apache 1.1 (Isto no de 1997), lembro-me bem dessa fase de BBS, saudades! ; (
#include "stdio.h"
int main(void) {
printf( "Content-Type: text/plain\n\n" );
printf("Eu estou rodando em CGI, em Linguagem C !\n");
return 0;
}
iríamos compilá-lo:
gcc olamundo.c -o olamundo.cgi
além de ter de mexer em muitas linhas de configuração do nosso Apache para executar nosso Script (compilado). E era assim que a Web era, antes mesmo da popularização das linguagens como PHP, Ruby, Java, NodeJS, e etc, etc, etc…
Tá, mas qual a razão de falar deste arcaico jeito de se programar? Hoje tem Docker, Frameworks, Low-Code e mais uma infinidade de soluções que auxiliam no desenvolvimento de aplicações de mais variadas camadas.
“se queres prever o futuro, estude o passado ”
Confucio
E com essa breve, porém verdadeira frase de Confucio podemos ter nosso passo inicial do que significa o contexto do Título do Post? Sim, caro leitor. É sempre necessário olharmos para trás, para entender o que veio para inovação, melhoria, assim os conceitos começam a ficar muito mais evidentes, nosso poder de abstração aguça e, consequentemente avançamos na criação de soluções e resoluções de problemas complexos.
Para se ter uma ideia, na Corrida Espacial usava-se Fortran, usavam Assembly para rotinas e subrotinas para a Missão Apollo 11, em que nos deu a oportunidade de pisarmos na Lua.
# Copyright: Public domain.
# Filename: LUNAR_AND_SOLAR_EPHEMERIDES_SUBROUTINES.agc
# Purpose: Part of the source code for Luminary 1A build 099.
# It is part of the source code for the Lunar Module's (LM)
# Apollo Guidance Computer (AGC), for Apollo 11.
# Assembler: yaYUL
# Contact: Hartmuth Gutsche <hgutsche@xplornet.com>.
# Website: www.ibiblio.org/apollo.
# Pages: 984-987
# Mod history: 2009-05-24 HG Transcribed from page images.
#
# This source code has been transcribed or otherwise adapted from
# digitized images of a hardcopy from the MIT Museum. The digitization
# was performed by Paul Fjeld, and arranged for by Deborah Douglas of
# the Museum. Many thanks to both. The images (with suitable reduction
# in storage size and consequent reduction in image quality as well) are
# available online at www.ibiblio.org/apollo. If for some reason you
# find that the images are illegible, contact me at info@sandroid.org
# about getting access to the (much) higher-quality images which Paul
# actually created.
#
# Notations on the hardcopy document read, in part:
#
# Assemble revision 001 of AGC program LMY99 by NASA 2021112-061
# 16:27 JULY 14, 1969
# Page 984
# NAME - LSPOS - LOCATE SUN AND MOON DATE - 25 OCT 67
# MOD NO.1
# MOD BY NEVILLE ASSEMBLY SUNDANCE
#
# FUNCTIONAL DESCRIPTION
#
# COMPUTES UNIT POSITION VECTOR OF THE SUN AND MOON IN THE BASIC REFERENCE SYSTEM. THE SUN VECTOR S IS
# LOCATED VIA TWO ANGLES. THE FIRST ANGLE(OBLIQUITY) IS THE ANGLE BETWEEN THE EARTH EQUATOR AND THE ECLIPTIC. THE
# SECOND ANGLE IS THE LONGITUDE OF THE SUN MEASURED IN THE ECLIPTIC.
# THE POSITION VECTOR OF THE SUN IS
# -
# S=(COS(LOS), COS(OBL)*SIN(LOS), SIN(OBL)*SIN(LOS)), WHERE
#
# LOS=LOS +LOS *T-(C *SIN(2PI*T)/365.24 +C *COS(2PI*T)/365.24)
# 0 R 0 1
# LOS (RAD) IS THE LONGITUDE OF THE SUN FOR MIGNIGHT JUNE 30TH OF THE PARTICULAR YEAR.
# 0
# LOS (RAD/DAY) IS THE MEAN RATE FOR THE PARTICULAR YEAR.
# R
# LOS AND LOS ARE STORED AS LOSO AND LOSR IN RATESP.
# 0 R
# COS(OBL) AND SIN(OBL) ARE STORED IN THE MATRIX KONMAT.
# T, TIME MEASURED IN DAYS(24 HOURS), IS STORED IN TIMEP.
# C AND C ARE FUDGE FACTORS TO MINIMIZE THE DEVIATION. THEY ARE STORED AS ONE CONSTANT(CMOD), SINCE
# 0 1 2 2 1/2
# C *SIN(X)+C *COS(X) CAN BE WRITTEN AS (C +C ) *SIN(X+PHI), WHERE PHI=ARCTAN(C /C ).
# 0 1 0 1 1 0
#
# THE MOON IS LOCATED VIA FOUR ANGLES. THE FIRST IS THE OBLIQUITY. THE SECOND IS THE MEAN LONGITUDE OF THE MOON,
# MEASURED IN THE ECLIPTIC FROM THE MEAN EQUINOX TO THE MEAN ASCENDING NODE OF THE LUNAR ORBIT, AND THEN ALONG THE
# ORBIT. THE THIRD ANGLE IS THE ANGLE BETWEEN THE ECLIPTIC AND THE LUNAR ORBIT. THE FOURTH ANGLE IS THE LONGITUDE
# OF THE NODE OF THE MOON, MEASURED IN THE LUNAR ORBIT. LET THESE ANGLES BE OBL,LOM,IM, AND LON RESPECTIVELY.
#
# THE SIMPLIFIED POSITION VECTOR OF THE MOON IS
# -
# M=(COS(LOM), COS(OBL)*SIN(LOM)-SIN(OBL)*SIN(IM)*SIN(LOM-LON), SIN(OBL)*SIN(LOM)+COS(OBL)*SIN(IM)*SIN(LOM-LON))
#
# WHERE
# LOM=LOM +LOM *T-(A *SIN(2PI*T/27.5545)+A *COS(2PI*T/27.5545)+B *SIN(2PI*T/32)+B *COS(2PI*T/32)), AND
# 0 R 0 1 0 1
# LON=LON +LON
# 0 R
# A , A , B AND B ARE STORED AS AMOD AND BMOD (SEE DESCRIPTION OF CMOD, ABOVE). COS(OBL), SIN(OBL)*SIN(IM),
# 0 1 0 1
# SIN(OBL), AND COS(OBL)*SIN(IM) ARE STORED IN KONMAT AS K1, K2, K3 AND K4, RESPECTIVELY. LOM , LOM , LON , LON
# ARE STORED AS LOMO, LOMR, LONO, AND LONR IN RATESP. 0 R 0 R
# THE THREE PHIS ARE STORED AS AARG, BARG, AND CARG(SUN). ALL CONSTANTS ARE UPDATED BY YEAR.
#
# CALLING SEQUENCE
# Page 985
# CALL LSPOS. RETURN IS VIA QPRET.
# ALARMS OR ABORTS
# NONE
# ERASABLE INITIALIZATION REQUIRED
# TEPHEM - TIME FROM MIGNIGHT 1 JULY PRECEDING THE LAUNCH TO THE TIME OF THE LAUNCH (WHEN THE AGC CLOCK WENT
# TO ZERO). TEPHEM IS TP WITH UNITS OF CENTI-SECONDS.
# TIME2 AND TIME1 ARE IN MPAC AND MPAC +1 WHEN PROGRAM IS CALLED.
# OUTPUT
# UNIT POSITIONAL VECTOR OF SUN IN VSUN. (SCALED B-1)
# UNIT POSITIONAL VECTOR OF MOON IN VMOON. (SCALED B-1)
# SUBROUTINES USED
# NONE
# DEBRIS
# CURRENT CORE SET,WORK AREA AND FREEFLAG
BANK 04
SETLOC EPHEM
BANK
EBANK= VSUN
COUNT* $$/EPHEM
LUNPOS EQUALS LSPOS
LSPOS SETPD SR
0
14D # TP
TAD DDV
## Comments in [...] are hand-written notations in original listing
TEPHEM # TIME OF LAUNCH [in centisec B 42]
CSTODAY # 24 HOURS-8640000 CENTI-SECS/DAY B-33
STORE TIMEP # T IN DAYS [@ B 9 = 512 days]
AXT,1 AXT,2 # [∴ granularity ≈ 0.164 sec]
0
0
CLEAR
FREEFLAG # SWITCH BIT
POSITA DLOAD
KONMAT +2 # ZERO$
STORE GTMP
POSITB DLOAD DMP*
TIMEP # T
VAL67 +4,1 # 1/27 OR 1/32 OR 1/365
# Page 986
SL DAD*
8D
VAL67 +2,1 # AARG
SIN DMP* # SIN(T/27+PHI) OR T/32 OR T/365
VAL67,1 # (A0**2+A1**2)**1/2SIN(X+PHIA)
DAD INCR,1 # PLUS
GTMP # (B0**2+B1**2)**1/2SIN(X+PHIB)
DEC -6
STORE GTMP # OR (C0**2+C1**2)**1/2SIN(X+PHIC)
BOFSET
FREEFLAG
POSITB
POSITD DLOAD DMP*
TIMEP # T
RATESP,2 # LOMR,LOSR,LONR
SL DAD*
5D
RATESP +6,2 # LOMO,LOSO,LONO
DSU
GTMP
STORE STMP,2 # LOM,LOS,LON
SLOAD INCR,2
X2
DEC -2
DAD BZE
RCB-13 # PLUS 2
POSITE # 2ND
BPL
POSITA # 1ST
POSITF DLOAD DSU # 3RD
STMP # LOM
STMP +4 # LON
SIN PDDL # SIN(LOM-LON)
STMP
SIN PDDL # SIN LOM
STMP
COS VDEF # COS LOM
MXV UNIT
KONMAT # K1,K2,K3,K4,
STORE VMOON
DLOAD PDDL
KONMAT +2 # ZERO
STMP +2
SIN PDDL # SIN LOS
STMP +2
COS VDEF # COS LOS
MXV UNIT
KONMAT
STORE VSUN
RVQ
# Page 987
POSITE DLOAD
KONMAT +2 # ZEROS
STORE GTMP
GOTO
POSITD
LUNVEL RVQ # TO FOOL INTEGRATION
SETLOC EPHEM1
BANK
COUNT* $$/EPHEM
STMP EQUALS 16D
GTMP EQUALS 22D
TIMEP EQUALS 24D
# *** END OF LEMP50S .115 ***
Trecho da Rotina de Efemérides Lunar e Solar no período da Missão, disponível no Github, além do todo o projeto.
Hoje você certamente iria ouvir de algum Youtuber/Coach Digital de Carreiras, que são linguagens mortas, mas eles mal sabem dizer o que é um algoritmo de estrutura de dados. Mas o Fortran/Assembly, criticado por essa gente vazia, levou a Humanidade até a Lua. Eles no máximo, compraram uma Blusa da Lacoste ou um iPhone 12 e votaram em seus participantes favoritos do Big Brother Brasil! x )
A fala entra nesta seara justamente pelo conteúdo pobre e sem sentido que muitas das vezes são encontrados em Blogs, Portais de Desenvolvedores, Canais de Vídeos, mundo afora. E após essa breve e importante introdução, vamos ao que interessa.
Linguagens Interpretadas
As Linguagens Interpretadas, são como uma espécie de análise sintática, através de um parser, passam por um tokenizer e por fim interpretadas por um interpretador que transforma o código em código de máquina, e assim ele é executado pelo Sistema Operacional. Exemplos de linguagens intepretadas: PHP, Python, Javascript, Ruby, Lua, R e uma infinidade de outras.
5 REM FATORIAL EM MSX BASIC 7 REM ADAPTADO MarMSX http://marmsx.msxall.com/ 10 INPUT"Qual o fator N";N 20 IF N<0 OR N>15 THEN 10 30 F=1 : IF N<2 THEN 70 40 GOSUB 200 70 PRINT"O fatorial e':";F 80 END 200 ' Funcao fatorial 210 IF N=1 THEN RETURN 220 F=F*N 230 N=N-1 240 GOTO 210
Um exemplo clássico é o MSX Basic, um projeto dos anos 80 que possuía o excelente processador Z-80 e na sua ROM, rodava um Interpretador Basic, em que era possível criar muitas aplicações interessantes. Inclusive foi neste ambiente, porém rodando em um IBM PC-XT, que aprendi a programar lá pelos idos de 1990. Saudades ; )
Como você pode observar, não houve necessariamente um compilador, o código foi interpretado e executado, vejamos agora um quadro de vantagens e desvantagens:
|
Vantagens |
Desvantagens |
| O código não necessita de um tempo para ser compilado para depois ser executado |
O tempo de execução pode ser mais lento, devido ser interpretada cada linha do código. |
| Não necessita de uma Plataforma ou Sistema Operacional para funcionar, basta um ambiente com um Interpretador |
Muito embora hoje a realidade é um pouco diferente, pois existem os compiladores JIT (Just in Time) que conseguem otimizar o acesso ao hardware, no caso do processador, bem como a memória, permitindo uma execução mais célere, tanto quanto um código compilado.
Linguagens Compiladas
Nas Linguagens Compiladas, o conceito é que temos um Analisado Léxico, Tokenizador, Linker, que enviará para o Compilador o código para execução.
Exemplos de linguagens Compiladas: C, C++, Pascal, Clipper, C#, Java, Fortran e outras infinidades por ai afora.
Vejamos o mesmo exemplo de algoritmo do Número Fatorial em C#:
/*
*Fatorial em C#
*
*/
using System;
namespace Fatorial
{
class Program
{
static void Main(string[] args)
{
int i, Numero, Resultado = 1, fatorial;
Console.WriteLine("Digite um numero para calcular seu fatorial:");
Numero = int.Parse(Console.ReadLine());
for ( i = Numero ; i > 0 ; i-- )
{
Resultado*= i;
}
fatorial = Resultado;
Console.WriteLine("O Fatorial do numero {0} é igual a {1};", Numero, fatorial);
Console.ReadKey();
}
}
}
Veja que a execução é muita rápida, razão esta que quando estamos diante um código compilado, os recursos do hardware são extremamente otimizados, e por consequência a execução tende a ser mais veloz. A desvantagem desta adoção é que ela precisa ter compatibilidade com o Sistema Operacional, hoje a Microsoft lançou sua plataforma de desenvolvimento .NET para Linux, o que executamos no código acima! ; ) <(“) <3 .
Conclusão
Como explanado acima, as linguagens compiladas levam vantagem não só por serem mais rápidas, e sim por serem mais eficientes com o hardware. Imagine uma Nave Espacial que necessita executar Comandos que não podem falhar, pois acarretaria em perda de vidas humanas na Missão, muito além do desempenho, as linguagens compiladas tem uma tolerância à falhas maior.
No entanto, quando usamos linguagens para o desenvolvimento web, por exemplo, não necessitamos (dependendo do cenário), de toda essa análise crítica, podendo muito bem ter em sua Stack ambas as soluções, tanto as Compiladas e as Interpretadas.
Espero que tenha sido proveitosa nossa conversa.
É melhor obter sabedoria do que ouro!
É melhor obter entendimento do que prata!
Provérbios 16:16