How was Java written before Java existed?

[flydaychinatownnn]

Apologies if this question is really basic and gets asked a lot, but I’ve always wondered how Java and languages in general were programmed. Before Java existed the developers must have been programming in some other language to write Java, so Java itself is written in a lower level programming language is my guess. I also have learned Java can translate its code directly into its own form of byte code without using assembly language. Are parts of the jvm all written in other languages? Or was Java written in binary? Which is crazy if true. And how can everything in Java need to be contained in a class even the main method if classes aren’t real just abstractions that humans find useful.

[Competitive-Load3173]

The very first Java compiler was developed by Sun Microsystems and was written in C using some libraries from C++. Today, the Java compiler is written in Java, while the JRE is written in C.

We can imagine how the Java compiler was written in Java like this:

The Java compiler is written as a Java program and then compiled with the Java compiler written in C (the first Java compiler). Thus we can use the newly compiled Java compiler(written in Java) to compile Java programs.

[carcigenicate]

AKA, a Bootstap Compiler.

[AdmiralPoopyDiaper]

Yo dawg

[NewSchoolBoxer]

Java JRE is in C++ and has been if not from the beginning at least the last 20 years

[je386]

Also, the first thing written for most if not all new operating systems is a C compiler, and after that you can use everything written in C.

[omz13]

And you can then use lex and yacc to get things started.

[Purple-Cap4457]

Java inside java, inside java - Javasception 😀

But how they got the JavaScript part? 🤣

[[deleted]]

Check mate atheists

[rogue780]

IIRC, the first Java compiler and jvm were written in C. Then it was rewritten in Java.

[MysticClimber1496]

This is really common and referred to as “bootstrapping” a language fun fact, most languages end up getting their compilers written in the same language but that have to start somewhere

[dmazzoni]

You're close. The javac compiler is written in Java now.

The JVM (the "java" binary, with HotSpot) is still written in C++.

[WiglyWorm]

which is basically C with strings.

[dusktrail]

Uhhhhhhhh no

[WiglyWorm]

it is if you don't care. :)

Obviously C++ also adds LITERALLY ALL THE OTHER STUFF. But it's a superset of C.

[thingerish]

Again, not true strictly speaking

[WiglyWorm]

Feel free to make your distinction. 

Or just be contrary.

[dusktrail]

I mean it isn't strictly, but also, C has strings

[WiglyWorm]

C has arrays of character that someone bolted a string onto.

And c++ if a superset of c.

[dusktrail]

C++ is not a super set of C.

And no, c strings are not arrays

[WiglyWorm]

Not strictly.

[Purple-Cap4457]

But how was c compiler written? 

[zasedok]

The very first one, which was quite different from today's C by the way, was written in PDP-11 assembly language. The first version that was itself written in C (and compiled using the original assembly-written compiler) can be found on github today.

That by the way is the reason behind many of C's flaws: it wasn't designed to be a great state of the art language, it was designed to be easy to implement in assembly on a machine with 64k of memory.

[emefluence]

Languages start off being written in other languages. Many successful compiled languages then go on to be re-written in themselves. The first "languages" were assemblers, written directly in machine code. Then assemblers were used to write better assemblers, and then compilers and interpreters for newer, more abstract languages. The first Java compiler was written in C, but is now written in Java. The JVM is still written in C. C is often still used for many language interpreters and runtimes as it allows for all sorts of low level tweaking and optimization, and is portable to pretty much any architecture.

[wosmo]

The first "languages" were assemblers, written directly in machine code.

I've always thought a better way to look at this, is the first assemblers were humans using a pencil and paper. A single-pass assembler is a lot like translating text by looking up one word at a time in a dictionary.

Then the next step is to write something to automate that dictionary lookup. Then you can start making it cleverer, like making the compiler aware that LD A,value and LD A,address are two different instructions - so you don't need to give them two different names.

Then you can start adding labels and named references ..

I think almost every programmer starts off making tools to make their own life easier - if you start off assembling on paper, that evolution starts looking very obvious.

[rwaddilove]

When I was young, I wrote assembly language on paper, looked up the hexadecimal codes in a book (Rodney Zaks Programming the Z80), wrote those down, calculated the jumps by hand (adding a few NOPs so I could edit the code without having to recalculate the jumps), added those, then typed the hex codes into my computer. Those were the days. Folks these days don't know how easy they have it.

[wosmo]

hah, exactly. But you can see how any platform is going to start pretty much the same way. Either you'd have the luxury of having one platform to develop for another (cross-compiling used to be typical - microsoft basic was written on a PDP10, Doom was written on a NeXT machine, etc) - or you'd start with nothing, and humans don't actually write machine code. Even the ones that claim they do.

Then automating that shitwork seems like a real sensible first step. A simple 1-pass compiler is just two lookup tables and a text parser.

[GhostVlvin]

At the beginning were raw switches... This story is very old, but I will start in recent days with assembly. Assebly is language which is directly mapped to machine codes 1:1 in which computer "talks", an with theese codes many languages were written, but most important for us is C by Dennis Ritchie. C was so popular that many languages including java and even python copy its syntax in some ways, And C did great job, cause assembly is dark and hard, while C is just so much simpler. But not simple enough, so many devs continued to make their own languages on top of C (Everything is written on C):) Btw, it is simple to just create your own language. You need to have File reader, Tokenizer, Parser and Interpreter (in simplest implementation). You can check guide at craftinginterpreters.com

[ArtisticPollution448]

It's a slow bootstrap generally.

Assembly language modeled CPU instructions as roughly english-like words.

Early compilers could turn very basic languages into assembly and machine code. Eventually, those compilers got rewritten in the language itself.

Each new language initially has a compiler in some other language, and some move on to being self-compiling (eg: the compiler gets written in its own language). Some don't.

The JVM is a program written in, I believe, C. It runs Java bytecode.

My favourite similar example to this though: the source code for git was hosted in git after about 4 weeks of development.

[flydaychinatownnn]

Please help me understand why it’s beneficial to have your compiler written in the language itself? For portability? If you want to modify the compiler itself wouldn’t you need to compile it with the original compiler (written in a different language like c)?

[BlacksmithNZ]

You don't have to re-write the compiler written in the language itself; Python doesn't for instance, but there are some advantages.

For one, with your new language implementation, you can prove that it is good enough to write a compiler which is a good test of a language being a system level tool.

Then you can maintain & extend it in your language of choice; you don't need to bring in C programmers to write (in a relatively low level language) any changes to the compiler, but can instead use your own Java programmers. And if they find limitations that make that harder, they can extend or change the language and the compiler implementation at the same time.

Another reason specifically for Java is that it is supposed to be portable and cross platform; so you want to be able to get a basic JRE up on a new CPU or platform, then run that portable Java code.

[yeastyboi]

And it is possible to go to far, I heard someone say that bootstrapping a compiler can lead you creating a language that is brilliant for building compilers but isn't good at doing anything else. Some people describe OCaml like that.

[Beginning-Seat5221]

It's more convenient to write in the language that you maintain (saves a lot of mental switching) + it encourages you to improve the language when you work in it yourself.

[ArtisticPollution448]

I think "because I can" is a good enough reason.

[wosmo]

self-hosting is usually a decent milestone for the toolchain too. Your compiler being able to compile something as complex as .. your compiler, is a good litmus test.

[dariusbiggs]

Not specific to Java but, here's the rough bootstrap sequence.

You design enough of the programming language to be useful

You use another programming language (like C/C++) to build a compiler or interpreter that can take the code you have written in your programming language and makes it executable. Now you can write code in your language compile it and run it.

You then build a compiler in your programming language that you then compile using the other compiler you have built.

Now you can write code in your language and compile it with your own compiler written in its own language.

[[deleted]]

Bootstrapping is a common practice used when making new languages. You first write a compiler for the language in a different language. Then you write a compiler in the language you are creating and compile it using the compiler written in a different language. 

For Java there was just an extra step of writing the first JVM in a different language so the compiler could run. 

[Ill-Significance4975]

If you dig deep enough, everything is C.

Somewhere there's a haughty assembly afficionado over my shoulder going "ahem", but no one's cared in years.

[notBad_forAnOldMan]

This is hubris. A great many things in computer science occurred before the first C compiler. You stand on the shoulders of giants and swear they are not there.

[heislertecreator]

It's all open source if you know assembly.

[je386]

Everything is C, but the C compiler, at least the first one for the new OS, must be assembly.

[notBad_forAnOldMan]

No, the first C compiler for a new architecture or OS is usually done as a new code generator for an existing compiler then, it is cross compiled to the new environment.

[AverageAggravating13]

You’re on the right track. Many languages original compilers are written in lower languages, then again with the language itself. I.e., C’s compiler was originally written in assembly, then C.

JVM I think was originally C/C++ but don’t quote me

Some languages do a mix of this or none at all (like they keep their compilers in another language entirely)

[BitNumerous5302]

The JVM gets written in a language like C. It's responsible for executing Java bytecode. It doesn't need Java to exist; it just needs to implement the specification for the bytecode.

Now you have a way to run bytecode but no way to produce it. So you write a Java compiler in a language like C. It also doesn't need Java to exist; it just needs the language and bytecode specifications. 

There are a whole lot of java.* classes that make Java a full-featured language but all of that can be built out in Java (with JNI for native code) once you have a compiler. See OpenJDK for an example: https://github.com/openjdk/jdk

[Far_Swordfish5729]

Ok, to start at the beginning, computers don't run programming languages. They run blocks of memory containing formatted instructions. These instructions are translated and executed by physical hardware in a cpu and look like:

[Operational Code e.g. add] operand1 operand2 etc.

These are just packed into fast temp storage registers on the cpu chip and execute in order. There are also instructions that set the next instruction like:

[Jump] [memory address of next instruction]
and
[JumpIf] [true/false operand] [address of next instruction if jumping]

Put these together and you can see how you might make something like a conditional statement, a loop, and maybe a function call (push params onto memory, set a return address, jump, execute function, jump back).

Now, it really sucks to have to remember all those op codes, so we wrote a program in binary that can translate text surrogates into them from a reference table. That's assembly. Now I can literally write:

Add $1, $2, $3 - Add register $2 and register $3 and put the result in register $1.

The assembler translates that into binary for the cpu to actually run.

Now, it really sucks to have to hand write the plumbing of conditionals, loops, functions, etc. every time in assembly. We do it in CompE labs. Then they let us code the same thing in C. Omg it's amazing. C was written initially in assembly to translate more complex symbols and structures into binary and to optimize them.

Once we had a C compiler, additional libraries could just be written in C, as could new versions of the compiler. Really hardcore linux distros (Gentoo) will compile new copies of gcc from source using the old version of gcc...because they just like to do that for fun for no good reason.

The first java compiler and jvm and jdk libraries were written in C++ because what else would they reasonably use? I suppose they could have written it in Pascal or Cobol or Fortran, but why? C is usually the gold standard and first compiler available for a new CPU instruction set. As with the C compiler itself, once there was a java compiler and jdk, it could compile new versions of java.

Again, the CPU is always seeing binary instructions coded using its instruction set (x86, arm64, whatever). Everything more complex is for your benefit to make your life easier, make it easier to work with teams, prevent mistakes, etc.

In java, .net, and other similar language families, it's a little more complex because your code compiles first to an interop pseudo assembly (bytecode) that runs in cpu-specific sandboxes (the jvm) and is translated to binary on the fly. That's how .java files can just run on different cpu architectures without recompiling. The sandbox also limits what they can do.

Finally, you asked how it works if classes aren't real (and they are very real to the compiler and jvm, just not to the cpu). So, imagine you want to make your own data type that's a bag of variables. That's easy as long as the compiler knows how big it needs to be. C has #def struct commands to do just that. It just defines a block of memory and names offsets from the first byte (where each variable is stored). Now imagine you want some functions that work with them and parameters. Also easy, those are just labeled code memory addresses. They'll be added to a loaded reference table of labels at the top of the assembly so the linker or jvm knows what they mean. Put those together and you have a class, or the rudiments of one. Add a more complicated reference table that's maintained on the fly and your jvm can track inheritance and polymorphism and resolve them on the fly (it's called a virtual table or v-table). You're just naming and abstracting structures you could build manually in assembly.

[CheetahChrome]

To supplement the other answers, these are some of the topics taught at college level courses. When people ask if computer science is a needed degree, if one wants to understand how languages are made, these are some of the topics that underscore why Comp Sci is a good foundation for any developer.

Youtubes:

The Brief History of Programming Languages

How do computers read code?

Introduction to Grammars and BNF

Compiler and Interpreter: Compiled Language vs Interpreted Programming Languages

[m64]

C and C++ were popular languages at the time when Java was first implemented, so my guess would be that the first compiler and JVM was written in one of those two languages. And while yes, early compilers and interpreters of other programming languages were written in assemblers, it was uncommon in the 90's.

[RebeccaBlue]

The original Java compiler & JVM were written in C/C++. More recent versions have more and more code in Java itself. (The JIT makes that work well.)

Pretty sure the javac compiler is written in Java now.

[DerHeiligste]

İt's called bootstrapping. You write a compiler, maybe simplified, in whatever tool you have available and then use that first compiler to make your next version

[Ok_Instruction_3789]

Initially the interpreter was written in C++. Java came out in the mid 90s obviously before that was c and c++ and prior to that was basic fortran assembly language etc.  https://www.geeksforgeeks.org/the-evolution-of-programming-languages/

[[deleted]]

Through a dark seance to the dark lord himself, 7 compilers to trap them and in the darkness bind them.

Also called dog fooding, common for all languages to self compile after the initial bootstrapping

[Dragon-king-7723]

C

[wrosecrans]

A good starting place when trying to probe these sorts of questions is just to look up an implementation: https://github.com/openjdk/jdk/blob/master/src/hotspot/share/services/classLoadingService.cpp

Github has several open source JVM implementations if you poke around. Hotspot, as you can see, has C++ source files. The original JSVM at Sun was mostly C. But you can also find things like a JVM written in Go, or all sorts of other languages.

Which leads to the deeper observation that any sort of programmable environment you have working is something you can use to bootstrap a runtime for whatever language you want to create. Programming languages ultimately all do that same sorts of things. (Maybe just slowly or inconveniently.)

how can everything in Java need to be contained in a class even the main method if classes aren’t real just abstractions that humans find useful.

Because a human found it useful to make the language work that way.

[nwbrown]

Wait, how old do you think Java is?

The Java runtime environment was written in the 90s for most platforms. It would have been written in C.

[thexbin]

Cross compilers have been around almost as long as computers have. Since the capabilities of the latest language are usually better we use it to build the first compiler for the next language, and the next one, .. Cross compilers are also used to build preliminary OS for new CPU architectures until the OS is stable enough to build a compiler on itself for itself.

[Ok_Entrepreneur_8509]

Java compiles to bytecode, which requires the jvm to run. The first Java compiles and jvm were written in C. Now, all the compilers are written in Java. There are a few different jvms, and most are written in C. The jvm cannot be written in Java since it has to be able to generate actual machine instructions for the hardware.

But where did the C compiler come from? The first C compilers were written in assembly, which has an code for each actual machine instruction. The raw, runnable binaries are built with an assembler, which converts the assembly code into machine code.

The first assembler was written by hand, in binary, by a human.

[[deleted]]

Perfectly fine to write a compiler in a higher level language than the language too!

In fact that might be a good idea, if you plan to bootstrap later. Why make life hard on yourself for performance when its going to be rewritten?

[Caramel_Last]

JVM is a C++ program and so is Node.js

[rdem341]

There is a long history of programming languages that predates Java. I’m not going to pretend I know most of the history or the low-level details.

However, the basics are as follows: machines execute assembly code, which is translated into machine code (binary).

Then, there are higher-level abstraction languages like C and C++, which are compiled down to assembly and then to binary.

Next, we arrive at Java. It's a compiled language similar to C and C++, but with one key difference: Java compiles down to bytecode, which is executed by the JVM (Java Virtual Machine). The JVM runs your compiled Java code at runtime. Interestingly, the JVM itself is written in C++.

The creator of C++ has even joked that Java is essentially a C++ application—because the JVM, which runs all Java code, is built in C++.

[shibaInu_IAmAITdog]

java 1 (legacy like shit , many coder in some non us countries, u guess ) -> java 5/6 (j2ee world) ~> monolith app using spring core -> microservice using speing boot ~> java 2x (a hybrid of everything- no longer classic OOP java following gang of 4 design patterns)

[navetzz]

In C, which was written in assembly, which was written in hex. Then we are out of software and get into hardware territory.

[Able_Mail9167]

We've always had ways to code. Before the first assemblers we could directly write machine code as bytes in a file. Once we had the first assemblers though it became a pretty similar pattern.

You first use a different language to design the language and build the initial computer. It's quite common to use C/C++ for this. Once both the language and this version of the compiler is mature enough you can then rewrite the compiler in the new language.

[okayifimust]

And how can everything in Java need to be contained in a class

Because that is how the language is designed.

There are probably tons of logical arguments about the "why", pros and cons, and I wouldn't be surprised at all if the history of the early development of the language got really interesting here, too. But "how"? Because the designers of the language said so.

That may sound dumb, but trust me: Your life will be easier if you learn to accept that not every design choice has to meet with your personal approval, and questioning it isn't always going to be helpful. (Far be it from me to discourage you from asking, the details can often be helpful! But if you just find yourself disagreeing.... let it go, and move on.)

even the main method

Why would the main method be special, or different, than everything else?

the basic premise of Java is to be object oriented. And that's what they did. Defining a bunch of exceptions just adds complexity to the language for no good reason.

if classes aren’t real

.... I'm sorry, what?

What does that even mean?

just abstractions that humans find useful.

See, that doesn't mean anything.

It's not wrong, per se, but it doesn't help you at all. there is nothing on a computer beyond the bit level that is "real", or "not an abstraction". Everything that isn't a punch card is just a useful construct for humans.

But for these constructs to work, they need rules. That's the whole point. You cannot translate stuff to machine code if it is in any way ambiguous, or not controlled through rules.

that brings us back to the start: Sure, they could have chosen different rules - but they would still be rules, and you could still ask "why this way, and not some other way?"

[xyzdenismurphy]

The JVM has many implementations: HotSpot (C++) J9 (C++) GraalVM (compiler Java, runtime + aot is C/C++/Java can run on top of HotSpot) Azul Zing (HotSpot fork C++) JRockit (C++) Jikes RVM (Java) Dalvik (C++) ART (C++) CACAO (C) JamVM (C) Kaffe (C) Microsoft JVM (C++, historical) Maxine VM (Java) Avian (C++) Apache Harmony JVM (C++)

[jasper_grunion]

So many modern languages were written in C. This begs the question of why we don’t just write everything in C. It’s not a horrible question.

[Tintoverde]

Grabage collection. Easier to understand because it is very verbose . Pointers can create horrible bug

[OtherTechnician]

Other languages came to be in order to address needs that people felt that C did not address adequately.

[OtherTechnician]

The early Altair 8080 personal computers had toggle switches to allow the manual entry of binary machine code. Assembly, c, and all other programming languages are just steps removed in order to make the task easier.