Say, I wanted to create my own programming language. Assuming that I have made all of the decisions about how I want it to look and act, do I just need to write a compiler for it?
For example, is the high-level Java code anything other than just text and this text is in the correct format for the compiler to accept it and turn it into something else?
My question is, is the creation of a programming language done through a compiler? High-level is fine.
The short answer is no.
You can think of a programming language as a mathematical formalism used for expressing computation. A compiler/interpreter is a just a piece of an actual software that carries out that computation, and should not serve as the language specification.
That being said, in addition to lexical and syntax specification of a language, you should also define semantic specification, i.e., what does a (syntactically correct) program written in your language actually mean. The obvious semantics to start with is operational semantics, where the meaning of a program is given in terms of how the program actually runs. That is, it (mathematically) precisely defines how programs execute. On top of this semantics you should build an actual compiler/interpreter with optimizations and so forth.
Specifying full operational semantics of your language will give you a formal language documentation and it will make you understand your language to the very details. Also, it will allow you to formally reason about some aspects of the language. Writing down operational semantics is really a good habit.
There are other useful semantics as well, such as axiomatic, denotational, and game semantics. However, they are more advanced and typically don't make their way into a compiler/interpreter.
Say, I wanted to create my own programming language. Assuming that I have made all of the decisions about how I want it to look and act, do I just need to write a compiler for it?
No. Making all of the decisions about how you want the language to look and act is creating your own programming language. You don't need a compiler or an interpreter to create a programming language. You don't need a compiler or an interpreter to write programs in your programming language.
You only need a compiler or an interpreter if you actually want to run the programs you write.
My question is, is the creation of a programming language done through a compiler? High-level is fine.
No. The creation of a programming language is done through coming up with two sets of rules:
That's it.
There are programming languages which have no implementation. Or which had no implementation for a long time.
For example, Konrad Zuse created Plankalkül in the mid-1940s, but due to the war he never was able to implement it. It was first implemented as part of a dissertation in 1975. But it certainly existed in the 1950s and 1960s.
LISP was originally designed as a more tractable alternative to λ-calculus for studying computation. It was implemented by Steve Russell, a student of John McCarthy. McCarthy himself even doubted that LISP could be implemented at all!
APL was originally designed as a notation for teaching mathematics. It was later extended to serve as the specification language for IBM System/360. Implementations came later, after the language had already been used.
PLANNER was a very influential language, which was actually only implemented after it had already influenced other languages; it was designed in 1969 and implemented in 1973, at which time it had already influenced Smalltalk and Prolog (both 1972).
Structure and Interpretation of Classical Mechanics is a physics textbook which uses Scheme instead of maths to describe dynamic systems; the fact that Scheme has interpreters and compilers is inessential for the book, it is used as a language for conveying thoughts, not running programs.
As you can see, programming languages can be useful even without implementations. "Programs should be written for humans to read, and only incidentally for computers to execute" is a famous quote from Structure and Interpretation of Computer Programs. Programming languages are formal languages for unambiguously describing complex processes. The fact that if you describe a process precisely enough for a human to understand, it also happens to be executable by a machine is a side-effect. It's a very desirable, useful, powerful, side-effect, but it is a side-effect.
The very first "programming languages", λ-calculus, SKI-calculus, Turing Machines, μ-recursive functions, weren't created for execution. They were created for understanding fundamental questions of logic and mathematics.
Is the creation of a programming language done through a compiler?
There are 3 options.
Assembler
Source code written by a human translates 1 to 1 into machine code consumed by CPU.
Interpreter
A program reads each line of code, follows the instructions and executes these in order.
Compiler
A program parses the statements often using an Abstract Syntax Tree and uses that to generate object code.
The compiler generate some form of object code that can be consumed by a real or virtual machine.
Blurring the lines
There are lots of intermediaries here.
Ruby runs from its AST. Java famously runs byte code for a fictional CPU.
SQL is interpreted, but does not get executed as written, it gets translated into a query plan.
Javascript exists in a weird twilight zone. It is interpreted for the most part, but critical parts are run through a JIT-compiler generating non standardized byte code and it is also used as the object code for some compilers.
Php used to be a pure interpreted language, but Facebook uses it's own php compiler.
My recommendation
If you want to experiment with writing a programming language.
Start with an interpreter.
If you want to understand compilers, study AST's !.
A language like Pascal is tailor-made for an AST it can go from source to machine code in a single pass and thus is relatively easy to implement in a compiler.
If you insist on studying compilers and not interpreters I recommend you study Wirth's writings on the subject.
All a compiler does is to ensure that the input it's given uses the language the compiler understands and that it carries the same semantic structure as the language.
The compiler fakes intelligence by making use a lexer and a parser in order to lexically analyse the input and try to parse the tokens into an order that has the intended meaning without introducing ambiguity.
To answer your question, you CAN create a programming language by creating the compiler, but in doing so, the programming language is actually created before the compiler is completed.
Think of programming languages as any other language out there - English, French, German, etc. The job of a compiler is, given some input, make sure the words used in that input match words used in the language it is built for, make sure that the ordering of the words make sense in the language it is built for and finally translate that input into a language that the machine can understand
I think a good way to think about it is half and half. I think what @zpavlinovic mentions is true, a language can exist without a compiler.
The way I like to think about it is that the language is a API/interface and a compiler is some implementation of said interface. There is a contract between the two that must be maintained, but outside of that the implementations (compilers) can be different.
You can write a program that takes input, parses it, and at the end either says “this is a valid program” or “this is not a valid program”. If that output is consistent, that is the same input always creates the same output, then your program defines a language. You can call this language a “programming language” if you like.
Now in practice let’s say there is a definition of the C programming language, and there is what your “C compiler” accepts. These are often not the same. Your C compiler defines a programming language which is likely not exactly the C language but hopefully close enough to be useful and acceptable.
System.out.println()Java because the Java compiler accepts that or is there some other thing working here. $\endgroup$