1
00:00:01,170 --> 00:00:03,910
Ciao, questo è Amanullah.

2
00:00:04,070 --> 00:00:09,980
Quindi, se avete visto che il software che utilizzerà linguaggi compilati come C non è indipendente dalla

3
00:00:10,710 --> 00:00:17,210
piattaforma, non guardate solo gli interpreti che sono solo un problema di dipendenza dalla piattaforma, ma come alcune altre limitazioni.

4
00:00:17,280 --> 00:00:23,190
È una caratteristica interessante ea volte anche gli ingegneri senior, ma non sanno come funzionano gli

5
00:00:23,190 --> 00:00:23,880
interpreti.

6
00:00:24,210 --> 00:00:26,430
Ma non sarebbe il caso per noi.

7
00:00:28,150 --> 00:00:34,810
Sappiamo che in un codice di compilazione il codice macchina generato dal compilatore sul codice macchina generato non

8
00:00:34,850 --> 00:00:41,290
viene eseguito separatamente dalla C. P. una lingua interpretata sembra diversa.

9
00:00:42,600 --> 00:00:48,970
In un linguaggio interpretato abbiamo un interprete che è un programma che esegue direttamente il codice

10
00:00:48,970 --> 00:00:49,470
sorgente.

11
00:00:50,660 --> 00:00:56,780
Cioè non esiste una compilazione separata I una fase di esecuzione come nel caso del linguaggio compilato.

12
00:00:56,780 --> 00:01:03,970
Come puoi vedere qui nell'interprete è il codice sorgente un'uscita è il risultato dell'esecuzione di quella fonte o

13
00:01:03,980 --> 00:01:11,820
così puoi vedere la somiglianza tra un interprete e SEP ACP che trasforma il codice macchina in risultati mentre un

14
00:01:11,820 --> 00:01:19,100
codice sorgente Doan di interprete nella sottomissione di dualismi il codice dice quindi il set di istruzioni per la

15
00:01:19,100 --> 00:01:20,560
s. p.

16
00:01:20,960 --> 00:01:21,840
Bene bene.

17
00:01:21,870 --> 00:01:24,450
Così è il set di istruzioni per l'interprete.

18
00:01:25,390 --> 00:01:30,050
Solo che quell'interprete è anche un programma e deve essere eseguito.

19
00:01:30,580 --> 00:01:35,870
Quindi CPQ esegue l'interprete, un interprete esclude internamente il codice sorgente.

20
00:01:37,820 --> 00:01:46,510
Quindi l'interprete non è nient'altro che una macchina virtuale che lo simula Sibiu che è solo un b b esigente manuale di linguaggio

21
00:01:46,720 --> 00:01:50,940
macchina che usa il fetch ed è un buon ciclo.

22
00:01:50,950 --> 00:01:56,890
Un interprete esegue anche le istruzioni nel codice sorgente in modo simile a quanto potrebbe fare un ciclo.

23
00:01:58,660 --> 00:02:02,390
Diamo un'occhiata a come i computer recuperano ed eseguono i libri del ciclo.

24
00:02:02,570 --> 00:02:09,560
La finzione è un buon psico è l'operazione più fondamentale di un computer che ogni programmatore deve sapere.

25
00:02:10,180 --> 00:02:13,600
Nel caso in cui non si abbia familiarità con questa breve discussione dovrebbe essere utile.

26
00:02:14,480 --> 00:02:17,190
Ora qui abbiamo una memoria CPO.

27
00:02:17,240 --> 00:02:25,820
Sotto questo programma per ottenere un buon risultato quando il programma viene eseguito o avviato il programma viene semplicemente caricato in

28
00:02:25,820 --> 00:02:32,060
memoria e sappiamo che un programma è un codice macchina ed è fondamentalmente una sequenza

29
00:02:32,480 --> 00:02:40,630
di istruzioni in cui ogni istruzione è semplicemente una sequenza di zero e uno successivo CPQ recupera un'istruzione da loro.

30
00:02:41,800 --> 00:02:51,790
Non nascosto che e nel processo può anche adattarsi a qualsiasi dato necessario per uscire dall'istruzione qualsiasi dato generato dall'esecuzione della build di istruzioni essere e

31
00:02:51,790 --> 00:02:57,730
tornare con una memoria C. P. che recupera la prossima istruzione

32
00:02:57,820 --> 00:02:59,060
su esecutivo.

33
00:02:59,410 --> 00:03:04,830
Quindi il ciclo continua fino a quando tutte le istruzioni del programma sono state eseguite.

34
00:03:04,900 --> 00:03:08,720
Quindi, in pratica, Scipio recupera un ciclo di vita operativo.

35
00:03:10,700 --> 00:03:18,220
Non letterali prendi interpreti ed è un buon retaggio di Buk anche l'interprete di Buhl recupera le sue

36
00:03:18,280 --> 00:03:25,690
istruzioni dalla memoria di Hulver, un interprete skees l'istruzione è fondamentalmente una dichiarazione nel codice sorgente.

37
00:03:27,260 --> 00:03:31,140
Comprende quindi ciò che è necessario per eseguire questa affermazione.

38
00:03:32,260 --> 00:03:40,020
E questi passaggi sono anche fatti dal compilatore il prossimo passo sarebbe una buona istruzione del programma.

39
00:03:40,260 --> 00:03:42,460
Ed ecco la cosa interessante

40
00:03:42,480 --> 00:03:50,220
L'interprete mantiene la libreria fuori dal codice macchina compilato ed esegue semplicemente il codice macchina

41
00:03:50,220 --> 00:03:53,880
compilato appropriato che corrisponde all'istruzione del programma.

42
00:03:53,940 --> 00:04:01,770
Quindi l'interprete non sta generando codice macchina, ma semplicemente usa il proprio codice macchina compilato per realizzare

43
00:04:01,890 --> 00:04:07,290
ciò che la sorgente Blorb rileva che effettivamente guarda un esempio.

44
00:04:07,390 --> 00:04:13,990
Qui abbiamo un'istruzione X nel codice sorgente sotto interprete esegue un codice compilato corrispondente dalla sua libreria

45
00:04:14,020 --> 00:04:20,410
che è una versione di codice macchina di questo blocco di codice che vedrai qui.

46
00:04:20,540 --> 00:04:26,710
Il codice sta recuperando i numeri per aggiungere un po 'di memoria e Dennis per svolgere l'attività.

47
00:04:27,000 --> 00:04:30,580
E finalmente sta iniziando a rimettere in memoria.

48
00:04:30,660 --> 00:04:38,800
Quindi, ancora una volta interpretor non sta generando codice macchina, ma usa la sua libreria fuori dalla macchina compilata.

49
00:04:40,580 --> 00:04:46,100
Uno dei principali vantaggi dell'interprete è il nero degli indipendenti, come si può vedere in

50
00:04:46,370 --> 00:04:53,450
questa illustrazione, lo stesso codice sorgente può essere eseguito su qualsiasi dorsale, il solo requisito è installare un interprete specifico

51
00:04:53,510 --> 00:04:55,240
per il buco nero.

52
00:04:55,770 --> 00:05:00,130
Si presenta con un linguaggio compilato che non siamo riusciti a raggiungere l'indipendenza di casa.

53
00:05:00,320 --> 00:05:06,440
Questo perché invece del codice sorgente stavamo usando un codice macchina che era nero dall'approfondimento.

54
00:05:06,790 --> 00:05:09,210
Quindi è una macchina catturata in gruppi attivi.

55
00:05:09,220 --> 00:05:13,520
È specifico per la piattaforma su cui è stato generato.

56
00:05:13,560 --> 00:05:18,870
Pertanto, la piattaforma di destinazione su cui deve essere eseguito il codice macchina potrebbe avere un set di attributi diverso

57
00:05:19,620 --> 00:05:22,370
sotto il codice macchina che non riuscirebbe ad eseguire.

58
00:05:22,770 --> 00:05:28,980
Ma con un linguaggio interprete stiamo eseguendo il codice sorgente identico indipendentemente dalla piattaforma su

59
00:05:29,070 --> 00:05:30,630
cui è scritto.

60
00:05:30,630 --> 00:05:33,580
Questo è bloccato da indipendente.

61
00:05:33,630 --> 00:05:39,210
È solo che l'interprete sulla piattaforma di destinazione garantisce che il blocco da codice

62
00:05:39,210 --> 00:05:42,080
sorgente indipendente venga eseguito senza problemi.

63
00:05:43,760 --> 00:05:50,750
Ora diamo un'occhiata ai pro e ai contro. Se un interprete voleva che un interprete

64
00:05:50,750 --> 00:05:56,120
includesse l'indipendenza dalla piattaforma, come abbiamo appena visto Max che non è completato.

65
00:05:56,410 --> 00:05:59,560
Questa è l'esecuzione di un programma può fermarsi immediatamente.

66
00:06:01,370 --> 00:06:07,400
Penso che uno dei principali vantaggi di non avere la fase di completamento sia che consentirebbe aggiornamenti più semplici,

67
00:06:08,270 --> 00:06:10,670
ad esempio in alcuni dei miei progetti.

68
00:06:10,850 --> 00:06:17,780
Ci sono stati casi in cui ho dovuto correggere bug nel codice javascript sui server di produzione. Dallas crep è

69
00:06:17,870 --> 00:06:23,690
un linguaggio interprete e quindi posso facilmente apportare le modifiche necessarie al codice direttamente sui server di

70
00:06:23,690 --> 00:06:26,500
produzione, ma mi è servito molto tempo.

71
00:06:26,540 --> 00:06:28,610
Ora come è stato un linguaggio compilato.

72
00:06:28,610 --> 00:06:34,700
Dovrei apportare le modifiche esternamente al codice compilato e quindi distribuire il codice

73
00:06:34,700 --> 00:06:39,930
compilato sui server di produzione che richiederebbe molto tempo prezioso.

74
00:06:39,960 --> 00:06:47,460
Ora, in termini di limitazioni, l'interpretazione è più lenta di ordini di grandezza che compilati o sono un paio di ragioni

75
00:06:47,460 --> 00:06:48,580
per questo.

76
00:06:49,600 --> 00:06:54,040
Uno sta facendo costose operazioni di accesso alla memoria.

77
00:06:54,280 --> 00:07:00,170
Ad esempio questo è il codice della libreria dall'esempio di istruzioni IDE che abbiamo visto in precedenza.

78
00:07:00,400 --> 00:07:06,000
Come puoi vedere ci sono diverse costose operazioni di accesso alla memoria in un linguaggio compilato.

79
00:07:06,010 --> 00:07:12,820
Sarebbe stato preso per scendere in registri che potrebbero portare a un cavo che funziona molto

80
00:07:12,880 --> 00:07:16,360
velocemente probabilmente anche 100 volte più velocemente.

81
00:07:16,360 --> 00:07:24,720
Seconda ragione per la lentezza è che il programma deve essere reinterpretato ogni volta che viene eseguito e la limitazione è

82
00:07:24,720 --> 00:07:28,720
che l'interprete viene caricato in memoria insieme al codice sorgente.

83
00:07:29,070 --> 00:07:32,820
Quindi hai un programma extra che viene caricato nella memoria.

84
00:07:32,850 --> 00:07:36,400
Non penso che sia un grosso problema, ma è solo qualcosa che dobbiamo sapere.

85
00:07:36,870 --> 00:07:41,470
Quindi, come possiamo vedere, gli interpreti risolvono il problema dell'indipendenza della piattaforma.

86
00:07:41,580 --> 00:07:45,530
Ha fatto come altre limitazioni come velocità di esecuzione lenta.

87
00:07:45,940 --> 00:07:48,910
Possiamo vedere come Java sia spaventato dal problema della velocità.

88
00:07:48,940 --> 00:07:51,790
Il compromesso tornato dall'Indipendenza.

89
00:07:52,080 --> 00:07:52,500
Grazie.