0:00:01.269,0:00:04.569
Você já viu pequeno código javascript trosos

0:00:04.569,0:00:08.119
Nesta seção, eu falo sobre o que conecta o mundo

0:00:08.119,0:00:11.431
com o código de máquina na CPU

0:00:11.431,0:00:13.595
Portanto, este será geralmente sobre o tema das linguagens de computador.

0:00:13.595,0:00:18.682
Portanto, um programador trabalhando em algumas linguagens de programação.

0:00:18.682,0:00:23.080
Diz-se que as linguagens de programação são funções de alto nível.

0:00:23.080,0:00:27.020
E isso significa coisas como loops (ciclos), e se o "se" declarações

0:00:27.020,0:00:30.032
e strings (cordas) e as instalações que são mais complicados

0:00:30.032,0:00:32.512
e estão em um código de máquina única na CPU.

0:00:32.512,0:00:36.298
Assim que o desenvolvedor escreve o que é chamado de código fonte

0:00:36.298,0:00:39.515
em qualquer linguagem de programação que você está escrevendo

0:00:39.776,0:00:42.498
Aqui é um exemplo de um código-fonte C + +.

0:00:42.498,0:00:45.769
Isso aloca uma string (string), uma variável e, em seguida, coloca uma

0:00:45.769,0:00:48.765
ponto de exclamação (!) no final da cadeia.

0:00:48.765,0:00:50.218
Isto é algo semelhante ao código javascript que temos visto.

0:00:50.218,0:00:52.465
Todas essas línguas ao nível da sintaxe

0:00:52.465,0:00:54.166
são um tanto semelhante.

0:00:54.166,0:01:02.805
Então, hum, como você obter o código fonte para C + +, por exemplo, em execução no CPU?

0:01:02.805,0:01:06.735
estratégia usa o que é chamado de compilador.

0:01:06.735,0:01:09.973
o compilador é um programa separado e que a

0:01:09.973,0:01:13.597
compilador é olhar para todo o código fonte

0:01:13.597,0:01:18.576
e faz com que uma tradução grande para criar uma grande corpo de código de máquina.

0:01:18.576,0:01:23.155
Por exemplo, pode haver uma parte da fonte,

0:01:23.155,0:01:26.967
onde há um "if" e não

0:01:26.967,0:01:28.922
instruções específicas para uma instrução de código de máquina "se"

0:01:28.922,0:01:31.002
mas pode haver uma sequência de instruções máquina 5

0:01:31.002,0:01:33.726
que é na verdade um "se"

0:01:33.726,0:01:36.515
Assim, o compilador faz esse tipo de expansão.

0:01:36.515,0:01:40.923
Assim, apenas como exemplo, o Firefox é escrito em C + +.

0:01:40.923,0:01:47.094
Portanto, para fazer uma nova versão do Firefox, alguém está

0:01:47.094,0:01:51.909
o C + + e ele lê em diversos arquivos de fontes,

0:01:51.909,0:01:54.594
o "corpo grande" do código-fonte que está em conformidade com o Firefox,

0:01:54.594,0:01:57.156
e produz basicamente firefox.exe

0:01:57.156,0:02:00.159
Firefox.exe é a saída do compilador para

0:02:00.159,0:02:03.620
traduzir todo o código fonte.

0:02:03.620,0:02:06.859
Algumas coisas a se notar é que,

0:02:06.859,0:02:09.880
compilar basta passar uma vez.

0:02:09.880,0:02:12.185
Assim, um corpo de código-fonte, alguém faz firefox.exe

0:02:12.185,0:02:15.885
e, em seguida, ser enviado firefox.exe

0:02:15.885,0:02:18.448
Os usuários finais não precisa do código-fonte e

0:02:18.448,0:02:20.609
não exigir que o compilador. Ele realmente faz a compilação

0:02:20.609,0:02:26.124
fábrica, na verdade. Outra característica é

0:02:26.124,0:02:30.381
não funciona em sentido inverso. Para que eu possa distribuir firefox.exe

0:02:30.381,0:02:34.295
Todo o código desta máquina, mas não algo que

0:02:34.295,0:02:36.899
pode ler e voltar a dar-me um grande corpo de código-fonte.

0:02:36.899,0:02:38.879
Pelo menos não perfeitamente, você pode fazê-lo de modo imperfeito.

0:02:38.879,0:02:41.981
Idealmente, para produzir um investimento realmente quer

0:02:41.981,0:02:44.761
o código-fonte. Então vamos falar sobre o código fonte.

0:02:44.761,0:02:51.947
Portanto, se você deseja adicionar funcionalidade ou corrigir um bug no firefox, realmente

0:02:51.947,0:02:53.965
o caminho é de volta para o código-fonte,

0:02:53.965,0:02:56.591
e revê-lo, só que eu fiz em java script.

0:02:56.591,0:02:58.266
Então adicione uma linha ou um comando if para alterar algumas

0:02:58.266,0:03:01.664
comportamento de alguma forma, no código fonte e depois executar

0:03:01.664,0:03:03.653
o compilador mais uma vez, na verdade, para fazer uma nova versão do

0:03:03.653,0:03:07.143
Firefox tem esta pequena alteração tem

0:03:07.143,0:03:10.971
no código fonte. Uma vez que estamos tendo em código-fonte,

0:03:10.971,0:03:14.414
Isso também dá uma boa noção de como aberto

0:03:14.414,0:03:18.870
software de código significa. Um software de código aberto é um

0:03:18.870,0:03:21.860
formato que distribui o programa, mas também

0:03:21.860,0:03:25.742
sem acesso à fonte original, o

0:03:25.742,0:03:27.734
o programa. Isso normalmente vem com uma licença,

0:03:27.734,0:03:29.714
dizendo: 'Ei, aqui está o código fonte. Se você quiser

0:03:29.714,0:03:32.879
fazer sua própria versão ou corrigir um erro ou qualquer outra coisa, este programa

0:03:32.879,0:03:36.755
Sinta-se livre. "Isso dos 2 principais características do software de código aberto

0:03:36.755,0:03:42.555
uma distribuição normal de graça, para você saber, o seu barato. Mas

0:03:42.555,0:03:45.985
Outra característica é que ele vem com um tipo de liberdade.

0:03:45.985,0:03:50.944
Porque se o software é de código fechado e

0:03:50.944,0:03:52.941
quero uma característica diferente, houve algumas falhas

0:03:52.941,0:03:55.671
necessário aplicar, você realmente depende do provedor, que tem a

0:03:55.671,0:03:58.311
código fonte, bem, eles se sentem como a aplicação

0:03:58.311,0:04:01.097
Será que esse recurso? Em contraste com o software de fonte aberta,

0:04:01.097,0:04:04.182
é como não esposas. O código fonte está disponível,

0:04:04.182,0:04:06.861
e se há algo que você realmente quer fazer,

0:04:06.861,0:04:10.060
ou dizer que o fornecedor original sai do negócio, em seguida,

0:04:10.060,0:04:15.029
porque você tem o código-fonte, você sabe, você pode ser

0:04:15.029,0:04:17.321
pagar alguém para fazer uma mudança e produzir sua própria

0:04:17.321,0:04:19.577
versão personalizada. Para o que vem com esse tipo de profundidade, uh-

0:04:19.577,0:04:21.649
pode ser considerado como uma apólice de seguro.

0:04:21.649,0:04:26.142
Muitas vezes, há muitos tipos diferentes de termos de licença

0:04:26.142,0:04:28.796
para software de código aberto, mas mais frequentemente

0:04:28.796,0:04:31.015
necessária em alguns casos, se você levar o seu

0:04:31.015,0:04:34.937
código-fonte e adicionar um recurso, em seguida, ele deve oferecer

0:04:34.937,0:04:37.564
essas alterações para a comunidade. Assim, no mesmo

0:04:37.564,0:04:39.767
forma se beneficiaram de um outro emprego, você pode se beneficiar de seu trabalho.

0:04:39.767,0:04:43.644
Os detalhes de como você pode fazer é complicado.

0:04:43.644,0:04:45.842
Existem muitas formas diferentes da mesma.

0:04:45.842,0:04:47.530
Eu vou falar sobre um software de código aberto

0:04:47.530,0:04:48.855
pouco mais tarde, eu só mencionei isso agora,

0:04:48.855,0:04:51.186
porque nos dá a idéia do que é o código fonte

0:04:51.186,0:04:54.602
programa contra apenas ter o algo. exe.

0:04:54.602,0:05:01.681
Até agora eu falei sobre C + +, assim é esta

0:05:01.681,0:05:04.771
qualquer outra grande categoria de línguas que

0:05:04.771,0:05:07.218
Eu vou chamar, ou linguagens dinâmicas, por vezes,

0:05:07.218,0:05:11.392
Interpretador da linguagem. E esta é uma espécie de um grande teste

0:05:11.392,0:05:12.436
estratégia e há muitas línguas diferentes, com

0:05:12.436,0:05:15.233
muitas qualidades diferentes e eu estou indo só para classificar de caroço,

0:05:15.233,0:05:17.156
tumor são nesta classe grande.

0:05:17.156,0:05:19.453
Exemplos de linguagens dinâmicas estão atualmente Java,

0:05:19.453,0:05:24.389
Java Script, e Python. Por conseguinte, vai para uma forma que estes são

0:05:24.389,0:05:26.506
trabalho é para ser aplicado pelo que é chamado

0:05:26.506,0:05:30.293
um intérprete. Eu acho que o compilador se você estivesse tomando antes.

0:05:30.293,0:05:36.156
Um intérprete é um programa que leva o código escrito em qualquer idioma

0:05:36.156,0:05:42.729
e tipo de [inaudível] é executado. O melhor exemplo é

0:05:42.729,0:05:45.703
é a linguagem de computador chamado java script,

0:05:45.703,0:05:49.271
na verdade, têm vindo a utilizar e navegadores web são

0:05:49.271,0:05:52.017
inclui programas como uma parte deles, um java

0:05:52.017,0:05:55.148
shell. E quando vem para o navegador web

0:05:55.148,0:05:57.471
através de uma página com código java script

0:05:57.471,0:06:00.604
pode usar o shell para executar esse código a ser

0:06:00.604,0:06:06.015
fazer tudo o que vai fazer. Assim, a forma como o interpretador

0:06:06.015,0:06:10.808
obras estão lidando com a agenda da linha 1 de cada vez.

0:06:10.808,0:06:13.891
Então aqui está algum código java script,

0:06:13.891,0:06:16.138
Se o jogador queria correr esse bem

0:06:16.138,0:06:17.726
ser visto na primeira linha e para procurar

0:06:17.726,0:06:19.669
que diz que linha e, em seguida, o intérprete

0:06:19.669,0:06:22.259
Eu o faria. Assim, neste caso, o intérprete dizer,

0:06:22.259,0:06:24.181
UH-Então eu acho que preciso de uma variável chamada A, e

0:06:24.181,0:06:25.992
Eu preciso colocar um 1 na mesma. Assim, uma vez feito com que a linha

0:06:25.992,0:06:28.531
em seguida, indo para a frente, e assim que faz a linha seguinte.

0:06:28.531,0:06:32.647
E assim por diante. O mesmo se aplica para o compilador do grande volume

0:06:32.647,0:06:36.718
tradução de código fonte em código de máquina

0:06:36.718,0:06:38.076
Mas isso realmente está executando o código, apenas a sua

0:06:38.076,0:06:39.657
fazendo a tradução para executar no futuro.

0:06:39.657,0:06:42.848
Por outro lado intérprete realmente viver o momento.

0:06:42.848,0:06:45.144
Somente através do código linha por linha e só

0:06:45.144,0:06:49.392
fazer. Então deixe-me falar um pouco sobre as diferenças

0:06:49.392,0:06:53.283
entre estes dois. Devo dizer que como um aviso legal,

0:06:53.283,0:06:55.773
Existem muitas linguagens de programação, não há melhor

0:06:55.773,0:06:59.418
a velha piada sobre a linguagem é que realmente sabe,

0:06:59.418,0:07:00.769
quando você está no seminário e quando você

0:07:00.769,0:07:01.916
discutindo sobre os prós e contras de algo,

0:07:01.916,0:07:04.871
finalmente, a resposta é simples, depende.

0:07:04.871,0:07:08.106
Como não há melhor linguagem, mas sim o que é

0:07:08.106,0:07:09.483
Melhores idiomas esta situação, todos os

0:07:09.483,0:07:13.336
características. Então, em termos gerais, apenas o código compilador

0:07:13.336,0:07:16.724
tende a correr mais rápido. Quando você compilar um código C + +

0:07:16.724,0:07:19.426
e produzir isso. exe é um tipo de carne magra em uma direção,

0:07:19.426,0:07:23.747
muitos detalhes e decisões tem sido despojado

0:07:23.747,0:07:26.886
, tanto quanto possível. Além disso dinâmico ou

0:07:26.886,0:07:30.714
intérprete de linguagem, tendem a ter mais recursos.

0:07:30.714,0:07:32.964
Mais recursos do que faz o trabalho de um programador

0:07:32.964,0:07:35.844
pouco mais fácil. Ou dito de outra forma, amplamente

0:07:35.844,0:07:39.197
falando, o programador pode tendem a fazer mais trabalho

0:07:39.197,0:07:41.907
por hora, linguagens dinâmicas, que fazem na compilação

0:07:41.907,0:07:46.811
Idiomas. Entretanto, não há almoço grátis, é

0:07:46.811,0:07:49.783
também o caso que o código de linguagem dinâmica tende a

0:07:49.783,0:07:52.660
ficar mais lento do que o CPU em termos de apenas ficando apenas

0:07:52.660,0:07:57.232
o trabalho realizado, em comparação com as línguas do compilador.

0:07:57.232,0:07:59.344
Código-fonte do compilador vai fazer o mesmo.

0:07:59.344,0:08:04.848
Então, um exemplo disso é um grande exemplo disso,

0:08:04.848,0:08:06.884
Gerenciamento de memória. Por meio do qual a gestão de memória refere-se à

0:08:06.884,0:08:09.868
problema no código de quantos bytes são

0:08:09.868,0:08:12.285
¿Necessário para armazenar algo em particular e por quanto tempo?

0:08:12.285,0:08:16.173
Bem, eu preciso desses bytes para a linha 6, você sabe, mas

0:08:16.173,0:08:18.276
talvez na linha 20, e não precisa mais

0:08:18.276,0:08:20.593
e realmente eu possa reutilizar por outra coisa.

0:08:20.593,0:08:23.144
E na verdade é um tipo de problema complicted.

0:08:23.144,0:08:27.006
Em C e C + +, gerenciamento de memória é um grau

0:08:27.006,0:08:29.773
Handbook. e isso apenas significa que o programador

0:08:29.773,0:08:31.315
estão ocorrendo todas estas linhas de código para as coisas

0:08:31.315,0:08:33.329
e será, por vezes, quando você pode ter um

0:08:33.329,0:08:35.554
adicionar algumas linhas para fazer algum pensamento, para ajudar a orientar

0:08:35.554,0:08:38.174
o gerenciamento de memória. Portanto, há alguns

0:08:38.174,0:08:41.437
esforço programador necessário. Em contraste, a maioria

0:08:41.437,0:08:43.925
Linguagens dinâmicas têm o que é chamado automático

0:08:43.925,0:08:46.869
Gerenciamento de memória. E isto significa que,

0:08:46.869,0:08:53.009
Entrada programador é necessário. A linguagem vai

0:08:53.009,0:08:56.944
automaticamente notar quando a memória é necessária,

0:08:56.944,0:08:58.064
Quando a memória não é necessário porque,

0:08:58.064,0:09:03.489
podem ser reciclados e tomar a este conjunto

0:09:03.489,0:09:04.805
problema. Portanto, se encaixa no interior da tendência dos

0:09:04.805,0:09:06.976
linguagens dinâmicas foi mencionando anteriormente,

0:09:06.976,0:09:09.405
Portanto, este é um exemplo de como, bem, você sabe, porque

0:09:09.405,0:09:11.735
o programador tem menos a ver, eles podem apenas

0:09:11.735,0:09:13.526
fazer as coisas um pouco mais rápido. Como o gerenciamento de memória

0:09:13.526,0:09:15.735
é um grande exemplo. No entanto também pode imaginar

0:09:15.735,0:09:17.189
Esta é uma das coisas que torna dinâmica

0:09:17.189,0:09:19.060
código de idioma correr um pouco mais lento. Porque,

0:09:19.060,0:09:22.914
o CPU agora tem livro suggestional mantendo problema

0:09:22.914,0:09:25.292
olhando para onde a sua memória e tentar

0:09:25.292,0:09:27.841
descobrir quando ele pode ser reutilizado. Por conseguinte, muito amplo

0:09:27.841,0:09:32.320
falando, a tendência para a equipe de programação de hoje

0:09:32.320,0:09:37.047
é para linguagens dinâmicas. A característica de que o

0:09:37.047,0:09:40.776
programador conseguir algumas coisas Liitle rápidas

0:09:40.776,0:09:43.242
à custa da utilização de uma CPU ou mais bits

0:09:43.242,0:09:45.930
memória é um equilíbrio muito atraente

0:09:45.930,0:09:49.162
muitos dos problemas. Este pode ser um pouco intuitivo,

0:09:49.162,0:09:51.874
mas você pode pensar que a má qualidade

0:09:51.874,0:09:54.876
para um programa de computador e é muitas vezes o

0:09:54.876,0:09:59.389
programador, que tem programador experiente trabalhando

0:09:59.389,0:10:01.204
que, você sabe, a trabalhar neste campo, muito

0:10:01.204,0:10:06.287
das vezes são difíceis de encontrar. E assim

0:10:06.287,0:10:09.105
suas horas, ou seja, usando algumas de suas horas,

0:10:09.105,0:10:12.635
tem uma aparência atraente, em contraste, a CPU sempre

0:10:12.635,0:10:13.929
Eu quero trabalhar o mais rapidamente possível, mas

0:10:13.929,0:10:17.424
CPUs são muito barato e bastante eficaz

0:10:17.424,0:10:19.073
e este efeito é ainda curioso onde este Moore

0:10:19.073,0:10:24.255
Lei, é cada vez mais certo, onde a CPU fica mais barato a cada ano

0:10:24.255,0:10:27.230
e se pensarmos o equilíbrio entre o programador

0:10:27.230,0:10:29.184
custo e CPU custo de obter algo,

0:10:29.184,0:10:31.781
Isto significa em termos de fatia do bolo,

0:10:31.781,0:10:33.477
o programador se tornar cada vez mais caro

0:10:33.477,0:10:36.169
cada ano um pouco mais escassos. Então, esses ajustes

0:10:36.169,0:10:41.364
no padrão. Em todas as linguagens dinâmicas

0:10:41.364,0:10:43.829
estão se tornando populares. A última coisa que será

0:10:43.829,0:10:46.561
mencionar é que existe algo chamado "JIT"

0:10:46.561,0:10:50.144
Just In compilador Time. E este tipo de

0:10:50.144,0:10:52.646
o compilador síntese natural e intérprete

0:10:52.646,0:10:54.772
estratégias, tentando obter o melhor dos dois mundos.

0:10:54.772,0:10:56.795
Assim, seu gosto, bem, nós gostaríamos de uma linguagem dinâmica

0:10:56.795,0:10:58.693
com todas estas características, todos estes programador favorável

0:10:58.693,0:11:02.019
características, mas queremos correr rápido. E assim

0:11:02.019,0:11:04.541
Este JIT assumir o código e teste

0:11:04.541,0:11:07.086
e compilar na mosca. Por isso, é uma espécie de

0:11:07.086,0:11:11.831
se casar com duas delas. Ele funciona

0:11:11.831,0:11:14.629
bastante bem. Assim, todos os navegadores têm agora

0:11:14.629,0:11:18.695
EIC para código Java script. Então, realmente quando você

0:11:18.695,0:11:22.316
O código JavaScript executado nesta classe,

0:11:22.316,0:11:24.616
dentro do navegador era um JIT que estava no

0:11:24.616,0:11:28.408
voar, tendo aqueles pedaços de código e Java Script

0:11:28.408,0:11:31.614
compilar em tempo real, em código de máquina.

0:11:31.614,0:11:35.362
De qualquer forma, não será exatamente formatos compilador

0:11:35.362,0:11:39.041
código, mas você chegar muito perto. OS. Isto é realmente

0:11:39.041,0:11:41.983
Como as linguagens mais dinâmicas. Ele é um ativo

0:11:41.983,0:11:44.390
área de pesquisa. Mas parece funcionar muito bem.