Placeholder Image

字幕表 動画を再生する

  • 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?

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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