
Turkish: 
Kendini derleyen derleyici ile bitireceğimiz son aşamayı yapacağız.
Önceki videoda yaptığımız şey, assembler yazarak bir C derleyici geliştirmekti.
varsayımsal olarak zaten ve
Bunun net sonucu, bilgisayarınızdaki belirli yonga setinde çalışan çalışan bir C derleyicisi almanızdır.
ARM olabilir, Intel olabilir, her neyse olabilirdi.
Yapmanız beklenenleri yapar. İçer
C programı ifadeleri ve diğer ucunda tükürür. Yani kod üreteci modülleri
Uygun bir şekilde paketlendiğinde, sizin için özel bir çalıştırılabilir hale gelecek olan İkili
makine parçası
Geleneksel olarak UNIX ve Linux altında. Bunlara geleneksel olarak noktadan çıkarılmış dosyalar denir ve pencerelerin altında nokta X denir, değil mi?

English: 
We're going to do the final stage. We're
going to end up with the self-compiling compiler.
Well, in the previous video what
we did was we developed a C compiler by
writing it in assembler (hypothetically
anyway). And the net result of that is you
get a working C compiler that works on
the particular chipset that's in your
computer. It could be ARM, it could be Intel,
It could be whatever. And it does
what you expect to do. It drinks
in C program statements and it spits out
at the other through its code-generator
modules a binary which, when suitably
packaged, will become an executable on
your particular piece of machinery.
Traditionally under UNIX and Linux these
are called a.out files. Traditionally,
under Windows, they are called .exe(s)
aren't they? But it's basically something

English: 
We're going to do the final stage we're going to end up with the self compiling compiler
Well in the previous video what we did was we developed a C compiler by writing it in assembler
hypothetically anyway and
The net result of that is you get a working C compiler that works on the particular chipset that's in your computer
it could be ARM, it could be Intel, it could be whatever and
It does what you were expected to do. It drinks in
C program statements and it spits out at the other end. So it's code generator modules a
Binary which when suitably packaged will become an executable on your particular
piece of machinery
Traditionally under UNIX and Linux. These are called a dot out files traditionally and under windows are called dot X's, aren't they?

English: 
but it's basically something that is very very close to a loadable venable binary as
Translation of your C program and we left it last time if you if you like you could say, this is our C
compiler
But we could almost call it the mark 1 because we're saying hypothetically
We developed it via an assembler root
so when it executes
It's running assembler quality binary and it's also producing shall we say assembler?
Quality binary I'll label that
Compiler mark 1 so you say well what's wrong with that?
Why not just stick like that. We've got a compiler that works. Well, it could be a variety of reasons
It could be that's all though. It's running binary of quality a that binary could be not very good
It could be slow. It could be a perfectly good compiler, but it seems to take forever
Yeah
That will be one good reason for doing it there might just possibly now
You hope not be a very very hidden bug

English: 
that is very very close to a loadable,
runnable binary as a translation of your C
program. And we left it last time ... 
if you like you could say this is our C
compiler but we could almost call it "The Mark I"
[version] because we're saying,
hypothetically, we developed it via an
assembler route. So, when it executes it's
running assembler-quality binary and
it's also producing, shall we say,
assembler quality binary. I'll label that
compiler "Mark I". So you say: "Well, what's
wrong with that?" Why not just stick like
that? We've got a compiler that works!
Well, it could be a variety of reasons. It
could be that although it's running
binary of quality 'a' that binary could be
not very good. It could be slow. It could
be a perfectly good compiler but it
seems to take forever Yeah! That will be
one good reason for doing it. There might
just possibly now - you hope not - be a very

Turkish: 
Ancak bu temel olarak, yüklenebilir bir ikili dosyaya çok yakın bir şey.
C programınızın çevirisi ve eğer isterseniz söyleyebilmeyi isterseniz, bu bizim C
derleyici
Ama neredeyse 1'e işaret edebiliriz çünkü varsayımsal olarak söylüyoruz
Bir assembler kökü ile geliştirdik
yani yürütüldüğünde
Takımcı kalite ikili çalışıyor ve aynı zamanda montajcı mı diyoruz üretiyor?
Kaliteli ikili ben onu etiketleyeceğim
Derleyici işareti 1, yani neyin yanlış olduğunu iyi söylüyorsunuz?
Neden sadece böyle yapmıyorsun? İşe yarayan bir derleyicimiz var. Şey, çeşitli sebepler olabilir.
Hepsi bu kadar olabilir. Bir ikiliyi çok iyi olmayabilir bir çiftlik çalışıyor
Yavaş olabilir. Mükemmel bir derleyici olabilirdi, ama sonsuza dek sürecek gibi görünüyor.
Evet
Bunu yapmak için iyi bir sebep olacak, belki de şimdi olabilir
Çok çok gizli bir böcek olmamasını umuyorsun

English: 
that for certain C imports
It just crashes. You hope that testing and debugging have removed all those but you can never be sure
so
There's maybe another reason that certain sorts of constructs sometimes caused it to crash. You don't want that
But what you're now saying is can we use a not
top-quality thing to make a better instance of itself. Now this is not a new idea
some of the commenters on my previous video have been pointing out the machine tool industry has been doing this for
ages using a not very good tool that's on its last legs as a means of making something that's sharper and better
you can imagine a 3d printer that has been produced in a
component-wise way by other 3d printers and there is a vital cog in the middle of it, which

English: 
very hidden bug that for certain C
inputs it just crashes. You hope that
testing and debugging have removed all
those but you can never be sure.
So, there's maybe another reason that
certain sorts of constructs
sometimes cause it to crash. You don't
want that. But what you're now saying is:
"Can we use a not-top-quality thing to
make a better instance of itself? 
Now, this is not a new idea. Some of the
commenters on my previous video have
been pointing out the machine-tool
industry has been doing this for ages
[i.e.] using a not very good tool, that's on its
last legs, as a means of making something
that's sharper and better. You can
imagine a 3D printer that has been
produced in a component-wise way by
other 3D printers. And there is a vital
cog, in the middle of it, which turns
around a lot for some reason or another

Turkish: 
belirli C ithalatları için
Sadece çöküyor. Test etmenin ve hata ayıklamanın tüm bunları kaldırdığını, ancak hiçbir zaman emin olamayacağınızı umarsınız.
yani
Bazı tür yapıların bazen çökmesine neden olmasının başka bir nedeni olabilir. Bunu istemiyorsun
Ama şimdi söylediğin şey bir kullanabilir miyiz?
daha iyi bir örnek yapmak için en kaliteli şey. Şimdi bu yeni bir fikir değil
önceki videomdaki yorum yapanların bir kısmı, makine sanayinin bunu yapmakta olduğunu gösteriyor.
daha keskin ve daha iyi bir şey yapmanın bir aracı olarak son ayaklarında çok iyi olmayan bir araç kullanarak yaşları
üretilen bir 3B yazıcıyı hayal edebilirsiniz.
Diğer 3B yazıcılar tarafından parça parça bir yol ve bunun ortasında hayati bir dişli var.

English: 
and gets worn and what you'd like to do
is to improve the quality of that vital
cog. You're worried that it's going to split
apart and ... So, why not program your
machine to make that vital cog on the
machine as it now is? And just hope it
[the printer] withstands the stress until the 
piece is made and then, when the piece is made,
it's got better tolerances and so on.
hopefully, than the bit it's replacing.
So, you take the bad piece out, throw it away,
and put the new one in. So you're
actually feeding back, into the machine
itself, a new instance of something that
is vital to its running. So, even out
there, in the everyday world, this
business of eating yourself, or producing
a better version of yourself, has been
around for a long time. And we're going to
do something very similar here. What I'm
saying is ideally I'd like to make "BIN a"
be history, and a thing of the past,
because I'd like to write a new version
of the compiler, which we will call "Mark II"

Turkish: 
Bir nedenden ötürü çok fazla şey dönüyor ve yıpranıyor ve yapmak istediğiniz şeyin kalitesini artırmak
Yakınındaki hayati dişli çark, ayrılıp bunu yapacak. Yani neden olmasın?
Makinenizi şu anda olduğu gibi makinedeki hayati bir dişli haline getirecek şekilde programlayın
Ve sadece parça yapılıncaya kadar strese dayanabileceğini ve sonra parça yapıldığında daha iyi olduğunu umalım
Toleranslar vb. Umarım o zaman bit değişiyor
Demek kötü parçayı çıkar ve fırlatıp yenisini içeri sok.
Yani aslında makinenin kendisine geri beslenmesinde hayati önem taşıyan bir şeyin yeni bir örneğini geri veriyorsunuz.
Bu yüzden günlük dünyada bile bu yemek yeme işi
kendiniz veya daha iyi bir versiyonunu üretiyorsanız
Uzun zamandır buralardayız ve burada çok benzer bir şey yapacağız. Demek istediğim
İdeal olarak, Bin A'yı yapmak istiyorum.
Tarih ve geçmişle ilgili bir şey çünkü derleyicinin yeni bir versiyonunu yazmak istiyorum

English: 
Turns around a lot for some reason or another and gets worn and what you'd like to do is to improve the quality of that
Vital cog near worried that it's gonna split apart and do it. So why not?
program your machine to make that vital cog on the machine as it now is
And just hope it withstands the stress until the piece is made and then when the piece is made it's got better
Tolerances and so on. Hopefully then the bit is replacing
So you take the bad piece out throw it away and put the new one in
So you're actually feeding back into the machine itself a new instance of something that is vital to its running
So even out there in the everyday world this business of eating
yourself or producing a better version of yourself
Has been around for a long time and we're gonna do something very similar here. What I'm saying is
Ideally, I'd like to make Bin A be
History and a thing of the past because I'd like to write a new version of the compiler

Turkish: 
Bu yüzden biz işaret 2 olarak adlandıracağız.
Bu şu anda a kalite ikili kodunu çalıştıran bir derleyici ve kod üreten
benzer kalitede bir ikili
Şimdi hala C ile yazılmış C derleyicisinin yeni bir versiyonunu yazıyoruz.
Bu sayede daha kaliteli bir ikili üretiliyor, kod üretme modüllerine çok dikkat ediyoruz, bu yüzden bunu bin B olarak adlandıracağız.
Versiyon 1 onun için bir versiyondur veya bazı anlamlarda ikili anlamda daha iyi kalitede B anlamına geldiğini düşünebilirsiniz.
Demek ilk yazdığın şey bu, C derleyicisinin yeni bir versiyonunu yaz.
C de alır
Bin B'yi üretir. Bu kod oluşturma modüllerine çok zaman harcadınız.
Ve elbette bu aşamada, C ile yazılmış olarak düşünürsünüz.
Hangi C yeni bir C derleyici yazıyorsun
Ancak yanan soru iyi geliyor, C'yi doğrudan donanıma uygulayamıyorum.

English: 
So, just to summarize, this is a
compiler running binary code of quality
'a' at the moment and code-generating
binary of a similar sort of quality. We
now write a new version of the C
compiler - still written in C - which
produces better quality binary. We pay a
lot of attention to the code-generation
modules, so we'll call it "BIN b"
Version 1 is 'a'. Version 2 is 'b'. 
Or you can think of the 'b' meaning "better" A "better
quality" -  in some sense - binary. So, that is
what you initially write. You write a new
version of the C compiler, which takes in C.
It produces "BIN b" -  you spent a lot of
time on that code-generation module - and of
course, at this stage you think of it as
being written in C - which it is. You're
writing a new C compiler in C but the
burning question then comes: "Well I can't

English: 
Which we will call mark 2 so just to summarize
This is a compiler running binary code of quality a at the moment and code generating
binary of a similar sort of quality
We now write a new version of the C compiler still written in C
Which produces better quality binary we pay a lot of attention to the code generation modules, so we'll call it bin B
Version 1 is a version to his be or you can think of the B meaning better best quality in some sense binary
So that is what you initially write you write a new version of the C compiler
which takes in C it
Produces bin B. You spent a lot of time on that code generation modules
And of course at this stage you think of it as being written in C
Which it is you're writing a new C compiler in C
But the burning question then comes well, I can't execute C directly on the hardware

English: 
execute C directly on the hardware - I
don't have a C interpreter". Although in
principle, I suppose, you could develop
one. No - that C has got to be turned
into binary. How do you turn that C, that 
it's written in, into binary when you are
in the process of constructing the new
thing? And the answer is:"Revert to the
previous generation". Revert to the one -
[the version] that you're hoping to leave behind - as a
means of propelling you forward, as part
of the bootstrap process. What we're now
saying is we do it like this: we write C
producing BIN b - the new version of the
compiler - written in C. How do we compile
that C? We have already got the old
Mark I version of the compiler, which
you'll remember from the top of the
previous sheet, takes in C runs on BIN a; it 
executes BIN a - and  let's hope it doesn't fall
over - and squirts out binary of quality 'a'.
But that's sufficient to show C going in

English: 
I don't have a C interpreter although in principle
I suppose you could develop one know that C has got to be turned into binary. How do you turn that C?
this is written in into binary when you are in the process of constructing the new thing and the answer is
revert to the previous generation
revert to the one that you've
Hoping to leave behind as a means of propelling you forward as part of the bootstrap process
What we're now saying is we do it like this we write
C producing bin B the new version of the compiler written in C
How do we compile that C we have already got the old Mark 1 version of the compiler?
Which you'll remember from the top of the previous sheet takes in C
runs on Bin A execute Bin A
let's hope he doesn't fall over and squirts out binary of quality a
But that's sufficient to show C going in there whirring round producing Binet. You've now got an

Turkish: 
Prensipte olmasına rağmen C tercümanım yok
Sanırım, C'nin ikili hale getirilmesi gerektiğini bilen birisini geliştirebilirsin. Bu C'yi nasıl çevirirsin?
Bu, yeni bir şey inşa etme sürecindeyken, ikili olarak yazılır ve cevap
önceki nesle geri dön
geri aldığın şeye
Bootstrap sürecinin bir parçası olarak sizi ileriye itmek için bir araç olarak geride bırakmak umuduyla
Şimdi söylediğimiz şey, yaptığımız gibi yapmak.
C üretici bin B, C dilinde yazılmış derleyicinin yeni sürümünü
Derleyicinin eski Mark 1 sürümünü zaten aldığımız C'yi nasıl derleriz?
Önceki sayfanın en başından hatırlayacağınız, C
Bin A'da çalışır Bin A'yı çalıştır
Diyelim ki düşmemesi ve ikilik bir kalite kazanması
Fakat bu, C'nin içeriye girip, Binet üreten yuvarlaklara döndüğünü göstermek için yeterli. Şimdi sahipsin

English: 
executable
Which takes in C
produces much better binary of quality B
it's only weakness is that it's still running itself on binary a
Maybe it's still slow maybe binary a is congenitally slow. It's not being very well written at all
But at least it works. It's there some final step. Yes, there is that would get rid of any vestigial
remains of bin a in all this
Process cycle. Yeah, that is exactly what you do next
we've got a new version of the C compiler, but it's
executable is only still of Bin A quality how to improve it feed the new version of the compiler to the
Executable that you have just created
And it would go like this
Look, here's your new mark 2 version of the C compiler C compiler written in C producing bin B
Feed it through

Turkish: 
yürütülebilir
C alır
B kalitesiyle daha iyi bir ikili veri üretiyor
bu sadece zayıflık, hala kendini ikilide çalıştırıyor olmasıdır.
Belki de hala yavaş ya da ikili bir doğumsal yavaş. Hiç iyi yazılmıyor
Ama en azından işe yarıyor. Son bir adım var. Evet, bu herhangi bir kurtuluştan kurtulacaktı.
Tüm bunlarda depo a kalıntıları
İşlem döngüsü. Evet, sonra aynen böyle yaparsın
C derleyicisinin yeni bir sürümüne sahibiz, ancak
çalıştırılabilir, yalnızca hala Bin A kalitesine sahip bir yazılımdır ve derleyicinin yeni sürümünü besleyiciye aktarma
Yeni oluşturduğunuz için çalıştırılabilir
Ve bu böyle giderdi
Bakın, işte C üretim kutusundaki B yazılan C derleyici C derleyicisinin yeni işareti 2 sürümü.
Besle

English: 
there, whirring round, producing BIN a.
You've now got an executable, which takes
in C produces much better binary of
quality 'b'. It's only weakness is that
it's still running itself on binary 'a'.
Maybe it's still slow? Maybe binary a is
congenitally slow - it's not been very
well written at all. But at least it works!
Is there some final step - yes
there is - that would get rid of any
vestigial remains of BIN a in all
this process cycle? Yeah! That is exactly
what you do next. We've got a new version
of the C compiler but its executable is
only still of BIN a quality. How to
improve it? Feed the new version of the
compiler to the executable that you have
just created and it would go like this, look:
Here's your new Mark II version of the C
compiler. [We have a] C compiler, written in C,

Turkish: 
 
Önceki
Önceki sayfanın sonunda geliştirdiğimiz şey, hatırlıyorsanız neyle sonuçlandığımızı
Şimdi derleyicinin C'den B'ye kadar yapabileceği bir sürümü
bu yüzden yeni bir versiyon, içindeki tek küçük zayıflık var
Ama bunu bir ikiliye besleyerek görebilir misiniz?
kendisi tarafından yürütülebilir
Yaptığınız şey, feed'inizdir, buradaki C Kutusu A Binasında çalışır, ancak B Kutusu'nu tükürür.
Yani nokta exe veya nokta topladığınız ne sonunda dosya değil, ne istediğinizi
C
B kutusu üretiliyor, ancak B kutusunda çalışıyor
yani bu şimdi yeni sürüm için çalıştırılabilir durumumuzdur, ancak güzel olan şey şu ki
Burada A'yı çalıştıran eski sürümü kullandığınız yerde zayıflık

English: 
The
Previous
thing that we developed at the end of the previous sheet what we ended up with if you remember is
A version of the compiler now that can do C to Bin B
so it's a new version the only little weakness inside it is it's running bin a
But can you see that by feeding that into a binary?
executable of itself
What you do is your feed your C in this is running on Bin A, but it spits out bin B
So what you collect in your dot exe or dot they doäôt file at the end is what you want
C
Producing bin B, but running on bin B
so this is now our executable for the new version but the beautiful thing about it, is that that
remaining weakness here where you use the old version running Bin A to produce a

English: 
producing BIN b. Feed it through the
previous thing that we developed, at the
end of the previous sheet, what we ended
up with, if you remember, is a version of
the compiler, now, that can do C to BIN b.
So it's a new version. The only little
weakness inside it is it's running BIN a.
But can you see that by feeding that,
into a binary executable of itself ... what
you do is you feed your C in. This is
running on BIN a, but it spits out BIN b.
So, what you collect in your .exe or 
a.out file at the end, is what you want: 
C producing BIN b but [also] running
on BIN b. So, this is now our executable
for the new version. But the beautiful
thing about it is that that remaining
weakness, here, where you use the old

English: 
version running BIN a to produce a
version that doesn't have BIN a in it
at all ...   Final stage:  feed that back to
itself and ... Ta! Dah!, (sound of trumpets); 
C written in C and producing BIN b, but as a
result of the previous exercise we've
now got a version of the compiler that
is the binary instantiation of this.
We have got, from over here, a C producing
BIN b, written in BIN b. Well, use it! 
Use it to recompile yourself and you end up
now with C, written in BIN b, producing
BIN b. Any memories of the hell we went through
with the Assembler version can now be
forgotten. You can throw that away and
carefully, of course, store away your
version now which only needs to get back
to a BIN b level of history, in order to
regenerate itself. And I suppose you

English: 
Version that doesn't have Bin A in this at all
Final stage feed that back to itself and that our sound of trumpets
C
written and C producing bin B
But as a result of the previous exercise, we've now got a version of the compiler. That is the binary
instantiation of this
We have got from over here a C producing Bin B written in bin B
Well use it use it to recompile yourself
And you end up?
now
with C
written in bin B
producing bin B any memories of the hell we went through with the Assembly version can now be forgotten you can throw that away and
Carefully, of course store away your version now
which only needs to get back to a Bin B level of history in order to regenerate itself and

Turkish: 
Bunda hiç Bin A bulunmayan sürüm
Son aşama, kendimize ve trompet sesimize geri döndü.
C
yazılı ve C üreten B kutusu
Ancak önceki alıştırmanın bir sonucu olarak, şimdi derleyicinin bir sürümüne sahibiz. Bu ikili
bunun somutlaştırılması
Buradan B kutusuna yazılmış bir B Bin kutusu üretiyoruz.
Kendini yeniden derlemek için onu kullan.
Ve sen sonunda?
şimdi
C ile
B kutusuna yazılmış
B binasını üretirken cehennemin anılarını derleme sürümüyle birlikte geçtikten artık unutup silebilirsin
Dikkatlice, elbette sürümünüzü şimdi saklayın
sadece kendini yenilemek için Bin B seviyesine geri dönmesi gerekiyor.

English: 
I suppose you could say therefore that this triumphant thing which I put three stars on here the product we were trying for all along
you can say it's now a
self-sufficient
Compiler as well as being a self compiling compiler
It's only needs a working and debug version of itself in
Order to be a wondrous new replacement now things are never quite that perfect
There's always a downside
I've got I've got a question because he kind of sort of alluded to it though. It skips over it nicely
Debugged right. I mean what happens if there are problems with this? You know, where do we go?
You always have to retain the ability to go back further than you would wish. Of course you do
It yeah, I think it is fair to say that
Compiling a C compiler is a very heavy and demanding task for a C compiler to do
You will get varieties of code

English: 
could say, therefore, that this triumphant
thing which I put three stars on here - 
the product we were trying for all along -
you can say it's now a self-sufficient
compiler as well as being a self-compiling 
compiler. It only needs a
working and debugged version of itself in
order to be a wondrous new replacement.
Now things are never quite that perfect.
There's always a downside ...
>> Sean: I've got a question because you kind of, sort
of, alluded to it though you skipped over it, nicely.
Debugged?! Right! I mean what
happens if there are problems with this -
you know where do we go with it?
>> DFB: You always haveto retain the ability to 
go back further
than you would wish, of course you do.
Yeah, I think it is fair to say that
compiling a C compiler is a very heavy
and demanding task for a C compiler to do :-)

Turkish: 
Sanırım, bu nedenle, üç yıldır koyduğum bu muzaffer şeyin, baştan beri denediğimiz üründe olduğunu söyleyebilirsin.
şimdi diyebilirsin
kendi kendine yeten
Derleyici yanı sıra kendi kendini derleyen bir derleyici olmak
Sadece kendi içinde çalışan ve hata ayıklama sürümüne ihtiyacı var
Harika bir yeni yedek olmak için sipariş şimdi işler asla bu kadar mükemmel değildir
Her zaman bir olumsuz tarafı vardır
Bir sorum var çünkü bir nevi buna itiraz etti. Üstünden atlar güzelce
Hata ayıklama hakkı. Yani bununla ilgili bir sorun olursa ne olur? Bilirsin, nereye gidiyoruz?
Her zaman istediğinden daha fazla geri dönme yeteneğini elinde tutmalısın. Tabii ki
Evet, bunu söylemenin adil olduğunu düşünüyorum.
Bir C derleyicisini derlemek, bir C derleyicisinin yapması gereken çok ağır ve zorlu bir iştir.
Kod çeşitlerini alacaksınız

English: 
Usages of data structures and all sorts in a
Compiler that you will not likely find in a weather forecasting program. Let alone an events listing
date calendar
Whatever a compiler is a demanding thing to write is going to be a demanding thing to compile
It may well be that just saying. Oh here's the old compiler that the old compiler just falls over when faced with the
Unbelievable quality of the C you've written for the mark to the thing
So yes that always happens you can feed it to itself and then itself falls over. What what do you do?
Well, you've got to back off and do it again, but you can see that in the end
It is the way to go get yourself
Use the whole idea revealing something to yourself
-
how shall we say motivate the quality of the C that you write to be compilable and
Giving a mind of course to efficiency and so on all the way along the chain

English: 
you will get varieties of code usages
of data structures, and all sorts, in a
compiler that you will not likely find
in a weather forecasting program, let
alone in an events-listing date-calendar, or
whatever. A compiler is a demanding thing
to write. It is going to be a demanding
thing to compile. It may well be that
just saying: "Oh! feed it to the old compiler ..."
But the old compiler just falls over
when faced with the unbelievable quality
of the C you've written for the Mark II
version of the thing. So, yes that always [often] 
happens. You can feed it to itself and then "itself"
falls over! What do you do? 
Well, you've got to back off and do it again.
But you can see that, in the end, it is
the way to go. Get yourself ... use the whole
idea of feeding something to itself
- to, how shall we say, motivate the quality
of the C that you write to be
compilable. And giving a mind, of course,

Turkish: 
Veri yapılarının kullanımı ve her türlü
Bir hava tahmin programında muhtemelen bulamayacağınız derleyici. Yalnız bir etkinlik girişi yapalım
tarih takvimi
Bir derleyici ne olursa olsun yazmak için zorlu bir şey derlemek için zorlu bir şey olacak
Sadece söyleyerek olabilir. Ah işte, eski derleyicinin karşılaştığı zaman düşeceği eski derleyici.
İşin damgası için yazdığınız C'nin inanılmaz kalitesi
Yani evet, her zaman olur, onu kendi kendine besleyebilirsin ve sonra kendi kendine düşer. Ne iş yaparsın
Geri çekil ve tekrar yapmalısın, ama sonunda bunu görebilirsin.
Kendine gitmenin yolu bu
Tüm fikri, kendine bir şey açığa vurmak için kullan
-
derlenebilir olması için yazdığınız C'nin kalitesini nasıl motive edeceğimizi ve
Tabii verimlilik boyunca ve böylece zincir boyunca yol boyunca akıl vermek

English: 
But I do hope that this example for those of you maybe been a bit puzzle saying what is all this bootstrapping?
One of the problems I think is that even sometimes when you see T diagram explanations
They make it hard by not
distinguishing if you like between Bin A and Bin B I've seen
Explanations which just right bin and don't make it clear that it's a different sort of binary, you know
And and that I think causes a lot of confusion
So I hope this has helped. Is it possible that this goes through oodles more? That's the technical term, oodles more?
Iterations, he got Bin C. Bin D, Bin E. Oh, yeah. Yes
yes, if you decide that well bin B was fine for its time, but frankly, there's a witty new idea with
interlocked
Triple Ref pointers pointing to data structures that do this and not the other and that's
Absolutely the way to write that next version of the C compiler then you can do exactly the same thing

Turkish: 
Ama umarım sizin için bu örnek belki de tüm bu bootstrapping nedir diyerek biraz bulmaca oldu?
Sanırım sorunlardan biri, bazen de T diyagramı açıklamalarını gördüğünüz zaman
Onlar tarafından zorlaştırılmaz
Bin A ve Bin B arasında istersen ayırt edici
Sadece doğru kutuya binen ve farklı bir ikili dosya türü olduğunu açıklığa kavuşturmayan açıklamalar.
Ve bence çok fazla kafa karışıklığı yaratıyor
Bu yüzden umarım bu yardımcı olmuştur. Bunun daha çok oodlardan geçmesi mümkün mü? Teknik terim budur, daha fazlası mı?
Tekrarlamalar, Bin C. Bin D, Bin E'yi aldı. Oh, evet. Evet
evet, eğer B haznesinin zamanı için iyi olduğuna karar verirseniz, ama açıkçası, bununla ilgili esprili yeni bir fikir var:
birbirine
Triple Ref işaretçileri, bunu yapan ve diğerini yapan veri yapılarına işaret eder.
Kesinlikle C derleyicinin bir sonraki sürümünü yazmanın tam yolu o zaman tam olarak aynı şeyi yapabilirsiniz

English: 
to efficiency and so on, all the way along
the chain. But I do hope that this
example, for those of you who have maybe been 
a bit puzzled saying: "What is all this
'bootstrapping' ?"  One of the problems I
think is that even, sometimes, when you
see T-diagram explanations they make it
hard by not distinguishing, if you like,
between BIN a and BIN b. I've seen
explanations which just write "BIN" and
don't make it clear that it's a
different sort of binary, you know.
And that, I think, causes a lot of
confusion. So I hope this has helped.
>> Sean: Is it  possible that this goes through
oodles more - that's the technical term :-) - 
oodles more iterations so you've got BIN c,
BIN d, BIN e ...
>> DFB:  Oh! yeah, yes, yes. If you
decide that, well, BIN b was fine for its
time but frankly there's a whizzy new
[code generation] idea with interlocked triple-ref
pointers, pointing to data structures
that do this that and the other, And that's
absolutely the way to write the next

English: 
You be daft not to use the previous version of the compiler to compile yourself
But what you must be careful of is that if you're in the process of as it were
defining
The subset of the language of the C compiler compiles your hope it will be total but there may be glitches in it
You've got to try and write C that it's capable of compiling itself and you've got that in your mind all the time
When you're doing this
Worst case scenario. Yes, exactly
Yes. Yes. I'm a fabulous compiler. But please don't feed me with myself all hell may break loose. Yeah. Yeah
And the cube mouse click events
We probably wouldn't get one whether the mouse is move
If you think about as the mouse is being moved
You've got lots and lots of events most of which you're not interested in
You're probably only interested when a button is pressed or so on the only times pass that's different
Is it cause for your dragging something around the screen?

Turkish: 
Kendinizi derlemek için derleyicinin önceki sürümünü kullanmamaya cesaret edersiniz
Ancak, dikkat etmeniz gereken şey, eğer olduğu gibi bir süreçte iseniz
tanımlarken
C derleyicisinin dilinin alt kümesi, toplam olacağına dair umudunuzu derler ancak içinde aksaklıklar olabilir.
Kendini derleyebilecek bir C yazmayı denemelisin ve bunu her zaman aklında tuttun
Bunu yaparken
En kötü durum senaryosu. Evet kesinlikle
Evet. Evet. Ben muhteşem bir derleyiciyim. Ama lütfen beni kendimle beslemeyin, cehennem gevşeyebilir. Evet. Evet
Ve küp fare tıklaması olayları
Muhtemelen farenin hareket edip etmediğine bakmak istemeyiz.
Farenin hareket ettiğini düşünüyorsanız
En çok ilgilenmediğiniz birçok etkinliğiniz var
Muhtemelen sadece bir düğmeye basıldığında ya da öylesine farklı olan tek seferde bir düğmeye basmakla ilgileniyorsunuzdur
Ekranda bir şey sürüklemenize neden oluyor mu?

English: 
version of the C compiler, then you can
do exactly the same thing. You'd be daft
not to use the previous version of the
compiler to compile yourself. But what
you must be careful of is that  - if you're
in the process of, as it were, defining
the subset of the language that the C
compiler compiles, you hope it will be
[a] total [subset]. But there may be glitches in it.
You've got to try and write C that is
capable of compiling itself. And you've
got that in your mind all the time when
you're doing this.
>> Sean:  It's its own worst-case scenario, right?
>> DFB: Yes, exactly! "Yes, yes, I'm a fabulous
compiler, but please don't feed me with
myself - all hell may break loose!" 
Yeah! Yeah!
