blocks|key|1822066|text|一般来说，你可以使用任何你喜欢的语言。例如，PHP就是用C语言编写的。如果您无法访问任何编译器，您将不得不求助于编写汇编语言，并手动将其编译为机器码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1822067|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Generally you can use just about whatever language you like. PHP was written in C, for example. If you have no access to any compiler whatsoever, you're going to have to resort to writing assembly language and compiling it to machine code by hand.

blocks|key|1822140|text|最常见的答案是C。大多数语言都是用C语言实现的，或者是C语言的混合体，带有回调函数和像Flex这样的“词法分析器”，以及像YACC这样的解析器生成器。这些语言的用途只有一个--描述另一种语言的语法。有时，当涉及到编译语言时，它们首先是用C实现的，然后使用该语言的第一个版本来创建一个新版本，依此类推。(比如Haskell。)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1822141|entityMap|0|LINK|mutability|MUTABLE|url|http://dinosaur.compilertools.net/|1|2|http://hackage.haskell.org/trac/ghc/wiki/Building/Porting^0|7|1|17|4|0|1P|4|1|49|7|2|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@$9|T|A|U|1|V]|$9|W|A|X|1|Y]|$9|Z|A|10|1|11]]|E|$]]|$1|F|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]|N|$5|I|J|K|E|$L|M]]|O|$5|I|J|K|E|$L|P]]]]

The most common answer is <code>C</code>. Most languages are implemented in C or in a hybrid of C with callbacks and a "lexer" like <a href="http://dinosaur.compilertools.net/" rel="noreferrer">Flex</a> and parser generator like <a href="http://dinosaur.compilertools.net/" rel="noreferrer">YACC</a>. These are languages which are used for one purpose - to describe syntax of another language. Sometimes, when it comes to compiled languages, they are first implemented in C. Then the first version of the language is used to create a new version, and so on. (Like <a href="http://hackage.haskell.org/trac/ghc/wiki/Building/Porting" rel="noreferrer">Haskell</a>.)

blocks|key|1822356|text|实际上，你几乎可以用任何你喜欢的语言来编写。没有什么可以阻止您用Ruby编写C编译器。“所有”你需要做的就是解析程序并发出相应的机器代码。如果你能读/写文件，你的编程语言可能就足够了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1822357|如果你在一个新的平台上从头开始，你可以进行交叉编译:为你的新平台编写一个编译器，它可以在Java中运行，也可以在x86上运行。在您的PC上进行开发，然后将程序传输到新的目标平台。|1822358|最基本的编译器可能是汇编语言和C语言。|1822359|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Actually you can write in almost any language you like to. There's nothing that prevents you from writing a C compiler in Ruby. "All" you have to do is parse the program and emit the corresponding machine code. If you can read/write files, your programming language will probably suffice.

If you're starting from scratch on a new platform, you can do cross-compiling: write a compiler for your new platform, that runs in Java or natively on x86. Develop on your PC and then transfer the program to your new target platform.

The most basic compilers are probably Assembler and C.

blocks|key|2036126|text|几乎任何语言，尽管使用一种适合于处理图形和其他复杂数据结构的语言将使许多事情变得更容易。出于性能原因，生产编译器通常是用C或C%2B%2B编写的，但OCaml、SML、Prolog和Lisp等语言可以更好地进行语言原型设计。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2036127|在语言设计中也使用了几种“小语言”。例如，Lex和yacc用于指定语法和语法，它们编译为C+(还有其他语言的端口，比如ocamllex+/+ocamlyacc和许多其他类似的工具)。|2036128|作为一个特例，新的Lisp方言通常构建在现有的Lisp实现之上，因为它们可以利用大多数相同的基础设施。编写Scheme解释器可以在Scheme中的一页代码下完成，在这一点上可以很容易地添加新功能。|2036129|从根本上说，编译器只是读入一些东西并将其翻译成其他东西的程序-将LaTeX源代码转换为DVI，将C代码转换为汇编语言，然后转换为机器语言，将语法规范转换为用于解析器的C代码，等等。它的设计者指定了源代码格式的结构(解析)、这些结构的含义、如何简化数据(优化)以及生成的输出类型。解释器读取源代码并直接执行它。(解释器通常更容易编写，但速度要慢得多。)|2036130|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

Pretty much any language, though using one suited to working with graphs and other complex data structures will make many things easier. Production compilers are often written in C or C++ for performance reasons, but languages such as OCaml, SML, Prolog, and Lisp are arguably better for prototyping the language.

There are also several "little languages" used in language design. Lex and yacc are used for specifying syntax and grammars, for example, and they compile to C. (There are ports for other languages, such as ocamllex / ocamlyacc, and many other similar tools.)

As a special case, new Lisp dialects are often built on existing Lisp implementations, since they can piggyback on most of the same infrastructure. Writing a Scheme interpreter can be done in Scheme in under a page of code, at which point one can easily add new features.

Fundamentally, compilers are just programs that read in something and translate it to something else - converting LaTeX source to DVI, converting C code to assembly and then to machine language, converting a grammar specification to C code for a parser, etc. Its designer specifies the structure of the source format (parsing), what those structures mean, how to simplify the data (optimizing), and the kind of output to generate. Interpreters read the source and execute it directly. (Interpreters are typically simpler to write, but much slower.)

blocks|key|1822774|text|很多语言都是自举的--那就是written+in+themselves。至于为什么要这样做，使用eat+your+own+dogfood通常是个好主意。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1822775|我提到的维基百科文章讨论了the+chicken+and+egg问题。我想你会发现它很有趣。|1822776|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Bootstrapping_%2528compilers%2529|1|https://stackoverflow.com/questions/1493747/bootstrapping-a-compiler-why|2|http://en.wikipedia.org/wiki/Bootstrapping_%2528compilers%2529#The_chicken_and_egg_problem^0|E|L|0|1C|K|1|0|D|J|2|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@$A|S|B|T|1|U]|$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|F|3|-4|5|6|7|12|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]|N|$5|I|J|K|C|$L|O]]|P|$5|I|J|K|C|$L|Q]]]]

A lot of languages are bootstrapped- that is <a href="http://en.wikipedia.org/wiki/Bootstrapping_%28compilers%29" rel="nofollow noreferrer">written in themselves</a>. As to why you would want to do this, it is often a good idea to <a href="https://stackoverflow.com/questions/1493747/bootstrapping-a-compiler-why">eat your own dogfood</a>.

The wikipedia article I refer to discusses <a href="http://en.wikipedia.org/wiki/Bootstrapping_%28compilers%29#The_chicken_and_egg_problem" rel="nofollow noreferrer">the chicken and egg</a> issue. I think you will find it quite interesting.

blocks|key|2036571|text|通常使用适合系统开发的通用编程语言，例如C、Haskell、ML、Lisp等，但选项列表很长。此外，通常使用一些领域特定的语言来实现语言，即解析器和词法分析器生成器，中间语言，如LLVM等。可能还有一些外壳脚本，测试框架，以及构建配置系统，如autoconf。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2036572|entityMap|0|LINK|mutability|MUTABLE|url|http://llvm.org/^0|2H|4|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Usually with a general-purpose programming language suitable for systems development, e.g. C, Haskell, ML, Lisp, etc., but the list of options is long. Also, usually with some domain-specific languages for language implementation, i.e. parser and lexical analyzer generators, intermediate languages like <a href="http://llvm.org" rel="nofollow noreferrer">LLVM</a>, etc. And probably some shell scripts, testing frameworks, and a build configuration system, e.g. autoconf.

blocks|key|2036692|text|“编写一种新的编程语言”在技术上不涉及任何代码。它只是为您的语言的外观和工作方式制定了一个规范。一旦你对你的语言有了一个概念，你就可以编写翻译器和解释器来让你的语言真正“工作”。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2036693|翻译人员输入一种语言的程序，输出另一种语言的等效程序。解释器输入某种语言的程序并运行它。|2036694|例如，C编译器通常将C源代码(输入语言)翻译成汇编语言程序(输出语言)。然后，汇编器获取汇编语言程序并产生机器语言。一旦你有了输出，你就不需要转换器来运行你的程序了。既然您现在有了一个机器语言程序，那么CPU就充当解释器。|2036695|许多语言的实现方式各不相同。例如，javac是一个将Java源代码转换为JVM字节码的转换器。JVM是运行Java字节码的解释器1。在运行javac并获得字节码之后，您不再需要javac。然而，每当您想要运行您的程序时，您都需要JVM。|offset|length|style|CODE|2036696|事实上，不需要让翻译人员在身边运行程序，这使得你可以“引导”你的语言，而不是让它在其他语言的层层之上运行。|2036697|1大多数JVM在幕后进行翻译，但它们并不是真正的翻译器，因为到JVM的接口不是"input+language+->+output+language“。|2036698|entityMap^0|0|0|0|H|5|1X|5|2G|5|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|U|8|@$H|V|I|W|J|K]|$H|X|I|Y|J|K]|$H|Z|I|10|J|K]]|9|@]|A|$]]|$1|L|3|M|5|6|7|11|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|12|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|Q|$]]

"Writing a new programming language" technically doesn't involve any code. It's just coming up with a specification for what your language looks like and how it works. Once you have an idea of what your language is like, you can write translators and interpreters to actually make your language "work".

A translator inputs a program in one language and outputs an equivalent program in another language. An interpreter inputs a program in some language and runs it.

For example, a C compiler typically translates C source code (the input language) to an assembly language program (the output language). The assembler then takes the assembly language program and produces machine language. Once you have your output, you don't need the translators to run your program. Since you now have a machine language program, the CPU acts as the interpreter.

Many languages are implemented differently. For example, <code>javac</code> is a translator that converts Java source code to JVM bytecode. The JVM is an interpreter [1] that runs Java bytecode. After you run <code>javac</code> and get bytecode, you don't need <code>javac</code> anymore. However, whenever you want to run your program, you'll need the JVM.

The fact that translators don't need to be kept around to run a program is what makes it possible to "bootstrap" your language without having it end up running "on top of" layers and layers of other languages.

[1] Most JVMs do translation behind the scenes, but they're not really translators in that the interface to the JVM is not "input language -> output language".

blocks|key|1823136|text|这不是一个愚蠢的问题。这是一个很好的问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1823137|正如已经回答的，简短的答案是“另一种语言”。|1823138|这就引出了一些有趣的问题？如果它是为你的特定硬件编写的第一种语言呢？对于在嵌入式设备上工作的人来说，这是一个非常现实的问题。正如已经回答的“另一台计算机上的一种语言”。事实上，一些嵌入式设备永远不会获得编译器，它们的程序将始终在不同的计算机上编译。|1823139|但你可以把它往后推更远。那么第一个编写的程序呢？|1823140|“高级语言”的第一个编译器应该是用“汇编语言”编写的。汇编语言是一种语言，该语言中的每条指令都对应于CPU的一条指令。它是一种非常低级的语言，非常冗长，编写起来非常费力。|1823141|但是即使是编写汇编语言也需要一个叫做汇编语言的程序来将汇编语言转换成“机器语言”。我们可以追溯到更远的地方。最早的汇编程序是用“机器代码”编写的。一种完全由二进制数组成的程序，这些二进制数与计算机本身的原始语言一一对应。|1823142|但它仍然不会结束。即使是一个只包含原始数字的文件也需要翻译。您仍然需要将这些原始数字保存在文件中并输入到计算机中。|1823143|信不信由你，早期的电脑前面都有一排开关。你翻转开关，直到它们代表一个二进制数，然后你点击另一个开关，将这个单一的数字加载到计算机内存中。然后你不断地切换，直到你加载了一个最小的计算机程序，可以从磁盘文件或穿孔卡片中读取程序。你轻敲另一个开关，它就启动了程序运行。当我在80年代上大学的时候，我看到计算机有这样的能力，但从来没有被分配到用开关加载程序的工作。|1823144|甚至比那更早的时候，计算机程序就必须与plug+boards硬连接！|offset|length|1823145|entityMap|0|LINK|mutability|MUTABLE|url|http://www.columbia.edu/cu/computinghistory/eniac.html^0|0|0|0|0|0|0|0|0|J|B|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|12|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|13|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|14|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|15|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|16|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|17|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|18|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|19|8|@]|9|@$R|1A|S|1B|1|1C]]|A|$]]|$1|T|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]]|U|$V|$5|W|X|Y|A|$Z|10]]]]

Its not a stupid question. Its an excellent question.

As already answered the short answer is, "Another language." 

Well that leads to some interesting questions? What if its the very first language written for 
 your particular piece of hardware? A very real problem for people who work on embedded devices. As already answered "a language on another computer". In fact some embedded devices will never get a compiler, their programs will always be compiled on a different computer.

But you can push it back even further. What about the first programs ever written?

Well the first compilers for "high level languages" would have been written in whats called "assembly language". Assembly language is a language where each instruction in the language corresponds to a single instruction to the CPU. Its very low level language and extremely verbose and very labor intensive to write in.

But even writing assembly language requires a program called an assembler to convert the assembly language into "machine language". We go back further. The very first assemblers were written in "machine code". A program consisting entirely of binary numbers that are a direct one-to-one correspondence with the raw language of the computer itself.

But it still doesn't end. Even a file with just raw numbers in it still needs translation. You still need to get those raw numbers in a file into the computer.

Well believe it or not the early computers had a row of switches on the front of them. You flipped the switches till they represented a binary number, then you flicked another switch and that loaded that single number into the computers memory. Then you kept going flicking switched until you had loaded a minimal computer program that could read programs from disk files or punch cards. You flicked another switch and it started the program running. When I went to university in the 80's I saw computers that had that capacity but never was given the job of loading in a program with the switches.

And even earlier than that computer programs had to be hard wired with <a href="http://www.columbia.edu/cu/computinghistory/eniac.html" rel="noreferrer">plug boards</a>!

blocks|key|2036906|text|许多语言首先是用另一种可用语言编写的，然后重新实现并以这种方式引导(或者只是用外语实现，如PHP和perl)，但有些语言，如第一个汇编程序，被手工编译为机器码，如第一个C编译器被手工编译为汇编。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2036907|自从我读到bootstrapping，我就对它很感兴趣。为了了解更多，我尝试自己编写自己的BF超集，我称之为EBF。EBF的第一个版本有3个额外的原语，我手工编译了第一个二进制文件。当我这样做的时候，我发现了一个两步的节奏。我在一个发行版中实现了当前语言的一个特性，并且有一个甜蜜的发行版，其中我重写了代码以利用实现的特性。该语言具有足够的表现力，可以用来制作LISP+interpreter。|offset|length|2036908|我有一个手工编译的版本和first+release+tag中的源代码，代码很小。最后的版本在大小和代码上都要大12倍，并且允许更紧凑的代码，所以手工编译当前版本将很难正确。|2036909|埃德蒙·格里姆利·埃文斯对his+HEX+language做了类似的事情|2036910|你自己做这件事的一个有趣的事情是，你理解为什么有些事情是这样的。我的代码是产品，如果是小的增量调整，它看起来更像是进化而不是从头开始设计的。当我今天阅读代码时，我会牢记这一点，我认为这看起来有点不对劲。|2036911|entityMap|0|LINK|mutability|MUTABLE|url|http://sylwester.no/ebf/|1|http://sylwester.no/zozotez/|2|https://code.google.com/p/ebf-compiler/source/browse/#svn/tags/ebfv1.0|3|http://homepage.ntlworld.com/edmund.grimley-evans/bcompiler.html^0|0|1I|3|0|50|G|1|0|C|H|2|0|D|G|3|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|10|8|@]|9|@$D|11|E|12|1|13]|$D|14|E|15|1|16]]|A|$]]|$1|F|3|G|5|6|7|17|8|@]|9|@$D|18|E|19|1|1A]]|A|$]]|$1|H|3|I|5|6|7|1B|8|@]|9|@$D|1C|E|1D|1|1E]]|A|$]]|$1|J|3|K|5|6|7|1F|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]]|M|$N|$5|O|P|Q|A|$R|S]]|T|$5|O|P|Q|A|$R|U]]|V|$5|O|P|Q|A|$R|W]]|X|$5|O|P|Q|A|$R|Y]]]]

Many languages were first written in another available language and then reimplemented in itself and bootstrapped that way (or just kept the implementation in the foreign language, like PHP and perl), but some languages, like the first assembler was hand compiled to machine code like the first C-compiler was hand compiled to assembly. 

I've been interested in bootstrapping ever since I read about it. To learn more I tried doing it myself by writing my own superset of BF, which i called <a href="http://sylwester.no/ebf/" rel="nofollow">EBF</a>, in itself. the first version of EBF had 3 extra primitives and I hand compiled the first binary. I found a two step rhythm when doing so. I implemented a feature in the current language in one release and had a sweet release where I rewrote the code to utilize the implemented feature. The language was expressive enough to be used to make a <a href="http://sylwester.no/zozotez/" rel="nofollow">LISP interpreter</a>.

I have the hand compiled version together with the source in the <a href="https://code.google.com/p/ebf-compiler/source/browse/#svn/tags/ebfv1.0" rel="nofollow">first release tag</a> and the code is quite small. The last version is 12 times bigger in size and the code and allows for more compact code so hand compiling the current version would be hard to get right. 

Edmund Grimley Evans did something similar with <a href="http://homepage.ntlworld.com/edmund.grimley-evans/bcompiler.html" rel="nofollow">his HEX language</a>

One of the interesting things about doing this yourself is that you understand why some things are as they are. My code was product if small incremental adjustments an it looks more like it has evolved rather than been designed from scratch. I keep that in mind when reading code today which I think looks a little off.

blocks|key|1823379|text|大多数编译器都是C或类似C的程序，如果不是C，那么汇编语言是可行的，然而，当你从头开始编写一个新的语言时，你没有宏库或原型语言的源代码，你现在必须用什么语言来定义你自己的函数？你可以在机器上编写一种叫做伪代码的源代码，它看起来像是来自面向对象的结构化语言规范的bnf语法，比如Fortran+basic+algo+lisp。所以，想象一下，编写一个类似于这些语言语法的交叉代码，这就是伪代码|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1823380|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Most compiler were wriiten C or a c like program if not c then assembly lang is the way to go However when writing a new lang from scratch and you do not have a macro lib or source code from a prototype language you have to define your own functions Now in What Language? You can just write a Form "of source code called psedocode to the machine it looks like a bnf grammar from the object oriented structured lang spec like Fortran basic algo lisp. So image writing a cross code resembling any of these language syntax That's psedo code

blocks|key|1823407|text|甚至进一步的二进制，或汇编操作必须被翻译成函数，这就是汇编程序/编译器的工作，然后是对象，从数据和函数，如果你没有一个源文件来了解“这些对象的功能应该如何在你的语言实现中表示，那么你必须认识到”看到“实现，或者定义你自己的函数，过程和数据结构，这需要大量的知识，你需要问自己什么是function.Your的头脑，然后成为区分主程序员和其他程序员的语言simulation.This。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1823408|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Even further binary ,or assembly operations must be translated into functions, thats the assemblers/compilers job, then into object,from data and functions, if you don't have a source file to see" how these objects functionality should be represented in your language implementation ,Then you have to recognize "see" implement, or define your own functions ,procedures, and data structures, Which requires a lot of knowledge, you need to ask yourself what is a function.Your mind then becomes the language simulation.This Separate a Master programmer from the rest.

blocks|key|1823560|text|几个月前我也有这个问题。我读了一些文章，看了一些视频，这帮助我开始编写我自己的语言，称为soft。它还没有完成，但我从这次旅程中学到了很多东西。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1823561|你应该知道的基本事情是当编译器必须执行代码片段时它是如何工作的。编译器有很多阶段，如词法分析、语义分析、抽象语法树(AST)等。|1823562|我用我的新语言做了什么可以在这里找到-+http://www.singhajit.com/writing-a-new-programming-language/|offset|length|1823563|如果你是第一次写一门语言，那么一切都好，你还有很长的路要走。|1823564|entityMap|0|LINK|mutability|MUTABLE|url|http://www.singhajit.com/writing-a-new-programming-language/^0|0|0|K|1O|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@$F|U|G|V|1|W]]|A|$]]|$1|H|3|I|5|6|7|X|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|Q]]]]

I too had this question few months back. And I read few articles and watched some videos which helped me to start writing my own language called soft. Its not complete yet but I learned a lot of stuff from this journey.

Basic things you should know is how compiler works when it has to execute a code snippet. Compiler has a lot of phases like lexical analysis, semantic analyzer, AST(Abstract Syntax Tree) etc.

What I did in my new language can be found here - <a href="http://www.singhajit.com/writing-a-new-programming-language/" rel="nofollow">http://www.singhajit.com/writing-a-new-programming-language/</a>

If you are writing a language for first time then all the best and you have a long way to go.

blocks|key|2037346|text|什么是一般的编程语言？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2037347|编程语言只是一种与计算机对话的方式。粗略地说，一开始，因为计算机只能理解0和1(由于计算机是由晶体管组成的开关，只能接受两种状态，我们称这两种状态为0和1)，对于我们人类来说，使用0,1是困难的，因此计算机科学家决定从二进制(0，1)中的每条指令进行一对一映射，以一种更人类可读的形式，他们称之为汇编语言。|2037348|例如，如果我们有这样的指令：|2037349|11001101|2037350|在汇编中，它将被调用：|2037351|LOAD_A+15|2037352|这意味着将寄存器a的内容加载到内存位置15。正如我所说的，这只是一种约定，就像在computer.in中为晶体管的两个状态或任何其他状态选择0和1一样。这样，拥有一个具有50条指令的程序，记住汇编语言将会更容易。所以用户会编写汇编代码，一些程序(在本例中是汇编程序)会将代码翻译成二进制指令或他们所说的机器语言。|2037353|但是，随着计算机的日新月异，有更多指令的更复杂程序的空间，比如说10000。|2037354|在这种情况下，像汇编这样的一对一映射将不起作用，因此创建了其他高级编程语言。他们说，例如，如果与I/O设备的关系需要大约80条指令来在屏幕上打印用户创建的东西，让我们在这里做一些事情，我们可以将所有这些代码打包到一个库中，并调用它，例如printf，还可以创建另一个程序，它可以将这里的printf转换为相关的汇编代码，然后汇编将从这里完成其余的工作。所以他们管它叫编译器。|2037355|所以现在每个想要在屏幕上打印一些东西的用户，他们不需要用二进制或汇编编写所有的指令，只需输入printf(“某种东西”)，所有的程序，比如编译器和汇编器，就可以完成剩下的工作。现在，其他更长的代码将以同样的方式打包，以方便其他人的工作，因为您可以将数千行代码简化为python中的一段代码，并将其打包供其他人使用。|2037356|假设你用python打包了很多不同的代码，创建了一个模块(libray，package或任何你想叫它的名字)，你把这个模块命名为mgh(就是我的名字)。现在假设我们以某种方式创建了这个mgh，任何人都会说：|2037357|import+mgh
mgh.connect(ip,port.data)...|code-block|syntax|javascript|2037358|可以很容易地使用指定的ip和端口号连接到远程服务器，然后发送数据(或类似的东西)。现在，人们可以用一行代码来完成所有的工作，但是发生的情况是，执行了许多从mgh文件中检索到的代码。打包它并不是为了加速执行过程，而是为了方便其他程序员的工作。因此，在这里，如果有人想先使用您的代码，他应该导入文件，然后python解释器将识别其中的所有代码，因此它可以解释代码。|2037359|现在，如果你想创建一种编程语言，并想要执行它，首先它需要一个翻译，例如，你创建了一个可以理解语法的程序，然后将它转换成c，在这种情况下，在它被翻译成c之后，剩下的就会由c编译器，然后汇编程序，链接器，……来完成。即使你必须付出更慢的代价，因为它必须首先转换成c。|2037360|现在你可以做的另一件事是创建一个程序，它可以把所有的代码翻译成等价的汇编语言，就像c一样，但在这种情况下，程序可以直接做，剩下的就由链接器来完成。我们知道这个程序叫做编译器。|2037361|所以我所说的是，系统唯一能理解的代码是0,1，所以你应该以某种方式将你的语法转换成0，1，现在在我们的操作系统中有很多不同的程序，比如汇编程序，链接器和……创建的目的是告诉您，如果您可以将代码转换为汇编语言，他们就可以处理剩下的事情，或者正如我所说的，您甚至可以通过将代码转换为其他编程语言来使用编译器。|2037362|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1B|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1C|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|1D|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|1E|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|1F|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|1G|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|1H|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1I|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|1J|8|@]|9|@]|A|$]]|$1|T|3|U|5|6|7|1K|8|@]|9|@]|A|$]]|$1|V|3|W|5|X|7|1L|8|@]|9|@]|A|$Y|Z]]|$1|10|3|11|5|6|7|1M|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|1N|8|@]|9|@]|A|$]]|$1|14|3|15|5|6|7|1O|8|@]|9|@]|A|$]]|$1|16|3|17|5|6|7|1P|8|@]|9|@]|A|$]]|$1|18|3|-4|5|6|7|1Q|8|@]|9|@]|A|$]]]|19|$]]

What are programming languages in general?
programming languages are a just a way to talk to computers. roughly speaking at first because computers could only understand zeros and ones (due to the fact that computers are made of transistors as switches which could only take two states, we call these two states 0 and 1) and working with 0,1 was hard for us as humans so computer scientists decided to do a one-to-one mapping from every instruction in binary(0,1) to a more human readable form which they called it assembly language.
for example if we had an instruction like:
11001101
in assembly it would be called:
LOAD_A 15
which means that load the content of register a into memory location 15. as i said it was just a convention like choosing 0 and 1 for two states of the transistors or anything else in the computer.in this way having a program with 50 instructions , remembering the assembly language would be easier . so the user would write the assembly code and some program (assembler in this case) would translate the codes to binary instructions or machine language as they call it.
but then with the computers getting improved every day there was room for more complicated programs with more instructions, say 10000.
in this case a one-to-one mapping like assembly wouldn't work, so other high level programming languages were created. they said for example if for a relation with I/O devices for printing something on the screen created by the user takes about 80 instructions , let us do something in here and we could package all this code into one library and call it for example printf and also create another program which could translate this printf in here to the related assembly code and from there the assembly would do the rest. so they call it compiler.
so now every user who wants to just print something on the screen he wouldn't have to write all the instructions in binary or assembly he just types printf(&quot;something&quot;) and all the programs like the compiler and assembler would do the rest. now later other longer codes would be packaged in the same way to just facilitate the work of other people as you see that you could just simplify a thousands line of code into one code in python and pack it for the use of other people.
so let's say that you have packed a lot of different codes in python and created a module(libray, package or anything that you want to call it) and you call that module mgh(just my name). now let's say we have created this mgh somehow that any one who says:
<pre><code>import mgh
mgh.connect(ip,port.data)...
</code></pre>
could easily connect to a remote server with the ip and port number specified and send the data afterwards(or something like that). now people could do all of it using one single line, but what that happens is that a lot of codes are getting executed which have been retrieved from the mgh file. and packaging it has not been for speeding up the process of execution but rather facilitating other programmers works. so in here if someone wants to use your code first he should import the file and then the python interpreter would recognize all the code in it and so it could interpret the code.
now if you want to create a programming language and you want to execute it , first it needs a translation, for example let's say that you create a program which could understand the syntax and convert it to c , in this case after it has been translated to c , the rest would be taken care of , by the c compiler , then assembler , linker, ... .
even though you would have to pay the price of being slower since it has to be converted to c first.
now one other thing that you could do is to create a program which could translate all the code to the equivalent assembly language just like what happens with c but in this case the program could do it directly and from there the rest would be done by the linker. we know that this program is called compiler.
so what i am talking about is that, the only code that the system understands is 0,1 , so somehow you should convert you syntax to that, now in our operating systems a lot of different programs like assembler, linker and ... have been created to tell you that if you could convert your code to assembly they could take care of the rest or as i said you could even use other programming languages compilers by converting your code to that language.

Please excuse my ignorance. I'm dabbling in PHP and getting my feet wet browsing SO, and feel compelled to ask a question that I've been wondering about for years:
When you write an entirely new programming language, what do you write it in?
This probably sounds really silly to all you programmers, for whom I have tremendous respect, but it's a perplexing chicken &amp; egg thing to me. What do you do? Say to yourself Today I'm going to invent a new language! and then fire up. Notepad? Are all compilers built on previously existing languages, such that were one to bother one could chart all programming languages ever devised onto one monstrous branching tree that eventually grounded out at... I don't know, something old?
With my feeble intellect, I find this fascinating. Please, educate me!

When someone writes a new programming language, what do they write it IN?

语义分析

数据结构

服务器

编译器

解释器

Java

请原谅我的无知。我正在涉足PHP，所以我觉得有必要问一个我多年来一直在思考的问题：当你编写一种全新的编程语言时，你会用什么来写呢？对你们程序员来说，这听起来可能真的很愚蠢，我对他们有极大的敬意，但对我来说，这是一个令人困惑的鸡和蛋的事情。你的工作是什么?对自己说，今天我要发明一门新语言！然后再发动起来。记事本？是不是所...

问当有人编写一种新的编程语言时，他们是用什么编写的？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问当有人编写一种新的编程语言时，他们是用什么编写的？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问当有人编写一种新的编程语言时，他们是用什么编写的？
EN