He’s the fcking best. Love this man.

An absolute tenure.

Indeed! Amazing :D

I'll try my best. ... Just keep the supportive comments coming in :-)

ProfDaveB Lol. Thx Professor Ty for making time for all of these amazing stories and tutorials. I hope you are working on a book. Cheers from Canada. !

The three hardest problems in computing. Naming things, cache invalidation and off by one errors...

Thanks for this, I will make a playlist >Sean

Portability. Java source programs are compiled into java class files in java bytecode which are still platform-agnostic. Those class files are usually packaged into a 'jar' file (glorified zip file) that can then be run by a Java Virtual Machine. The JVM can decide whether to interpret the bytecode or compile it down to machine code at runtime and then run that generated code - this is the JIT compilation process you were talking about. The java bytecode is the intermediate format - and it can be run on any platform that has a JVM available.

Compiling takes a really long time. Even small programs can take many minutes to compile on modern hardware. While it might improve performance a little while running, the cost would all have to be paid up front the first time you run the program on your machine. Imagine having to wait 1-5 minutes for your java program to "compile" the first time you try running it. Additionally, this now fully compiled code is no longer portable, so you have an increased memory footprint as you have to keep the compiled version of the code for any subsequent runs on the machine while also keeping an intermediate code copy as to maintain portability. It increases the complexity in sharing the code: If I want to send you the program, I have to make sure I send you the bytecode not the compiled code by accident otherwise you're out of luck! Any time the code updates even slightly, you will have to dump the compiled code and compile it all over again. I believe there are setting which can make java run this way, but the hassle of it generally outweigh the benefits.

The main reason is that the JIT compiler can collect profile information on which way your code actually usually goes at each branch from the particular run of the program. This allows it to compile a binary that will run faster on your actual input when there's a trade-off to be made. They wanted to generate the binary on the machine where it would run for portability and optimizing for your particular CPU model, but they could have compiled each program fully the first time you ran it and kept it if they weren't trying to benefit from having information about what you're doing this time.

Java bytecode, like Microsoft IL, is primarily designed for interpretation, with compilation more of an afterthought. LLVM is designed for compilation to efficient target code, not interpretation. It is built around SSA specifically for this reason.

@@imacds I don’t see that at all. Small programs compile quite quickly on a Linux system. A large program, like Blender (more than a million source lines) I can build in about 10 minutes.

Yeah, check out the "Red Dragon Book" by Aho and others. Also, if you wanna see the actual process of fully working compiler implementation, thanks watch Bisqwit's videos on you, he is incredible! Also, it's always quite possible to roll down your compiler, just do dig down in Computer Science and Software Engineering, learn some automata theory, various optimization tricks, computer architecture... This journey can be really interesting and you can become a 'natural geek' :) All the best to you.

Usually I* in practice means that the compiler has noticed things like the program saying days*60*60*24 instead of days*86400, and gone ahead and done that math. It can also come up with special versions of functions that only work if you call them with particular arguments and skip work that isn't needed with those arguments, and swapped those in where they will definitely work. This sort of optimization doesn't depend on the target binary, although it may want to ask the back-end about some trade-offs, like how expensive a function call is.

@@iabervon ah, Ok, so mostly stuff that you would do for compiling to any target?

Not only in the 1960s and 1970s, they still do. So do FORTRAN, PL/1 and the latest COBOL compilers.

@@isabellabihy8631 Thanks for the information. (Reading the compiler's Assembler output helped me learn it.)

Username checks out

Consider that byte-addressability was touted as a big advantage back in the days of ASCII and other 7/8-bit character sets. Now that Unicode is becoming pretty much universal, is that still so important?

why?

Thanks for ruining this video for me 😂 this can't be unseen.

@@fablungo My work here is done :)

Yes. It's how most modern compilers work.

as a low level programmer, can confirm

As a Python hobbyist dabbling into Coconut (even higher level of abstraction - that thing _transpiles to Python_), I see it. But, as a scientist as well, I value the shoulders of giants I stand upon and don't want them to be upset about it - after all, standing on the shoulders of giants is moves humanity forward _with ever-growing speed_.

Same lol i call them Coders as opposed to programmers as a low key insult haha

It's 100% relevant today. New high-level languages, new architectures, & new intermediate languages are appearing all the time.

No it's not hard to tell at all. Almost all modern compilers use an intermediate language, many even use LLVM (as the professor mentioned).

Windows developer, still believing that x86 is the (rapidly-shrinking) centre of the world? Compare an open-source OS like Linux, which runs on every major processor architecture for which GCC can generate code - that’s about two dozen of them at the moment. And userland apps that run under Linux are just as portable. Addition of new architectures hasn’t stopped. Consider the new hotness that is RISC-V. Meanwhile, Windows is still struggling to move off x86 onto ARM ...

Great and you?

i am fine as well

hello hello

@@kenkiarie you've never eaten a fantasy? What?

^2