{"id":52,"date":"2020-11-25T22:18:51","date_gmt":"2020-11-26T03:18:51","guid":{"rendered":"https:\/\/www.alpharithms.com\/?p=52"},"modified":"2021-07-20T22:45:12","modified_gmt":"2021-07-21T02:45:12","slug":"computer-translation-hierarchy","status":"publish","type":"post","link":"https:\/\/www.alpharithms.com\/computer-translation-hierarchy-511822\/","title":{"rendered":"Computer Translation Hierarchy"},"content":{"rendered":"

What happens when a computer program runs? What happens when a developer compiles<\/em> a program? These are questions fundamental to the process of Computer translation and are essential in understanding how computers ingest human-friendly languages and turn them into machine code.<\/p>\n

Modern translation pipelines often make use of distributed systems like cloud-based solutions,<\/a> dynamic link libraries, and virtualization<\/a>. Advances in translation strategies are nothing short of inspiring. At their heart, however, these pipelines encompass several fundamental steps having been taking by Computer Scientists for decades.<\/p>\n

Machine Translation Steps<\/h2>\n
\"computer
These four steps are fundamental in translating human-readable code to machine-readable formats<\/figcaption><\/figure>\n

Each step involved in translating high-level programming languages to machine code involves plenty of complexities. However, each can be regarded as completing one discrete stage of the process. Below, you’ll find a brief outline of each step and its role in the process of translating languages like C and Java into 1’s and 0’s.<\/p>\n

Compiler<\/h2>\n

The compiler translates the programming language of one machine into the programming language of another. Generally, this process involves converting high-level language such as C into lower-level language like assembly code.\u00a0The compiler<\/a>\u00a0is tasked with several jobs including preprocessing, lexical analysis, and code optimization.<\/p>\n

Input:<\/strong> Takes a high-level language like C, Java, or C++<\/p>\n

Output<\/strong>: Assembly language<\/p>\n

Assembler<\/h2>\n

The assembly generates\u00a0object<\/em>\u00a0code by translating the code generated by the compiler. Assemblers are tasked with creating a binary version of instructions generated by the compiler. This involves keeping track of labels used in portions of code that recur, such as procedures and static variables. The assembler does this with a\u00a0Symbol table<\/em> which consists of symbol:memory_address<\/code> pairs.<\/p>\n

Input<\/strong>: Assembly language<\/p>\n

Output<\/strong>: Machine language objects<\/p>\n

Linker<\/h2>\n

Sometimes referred to as the link editor, the Linker allows programs to only re-compile certain components rather than re-compiling the entire codebase. The linker gathers all the different assembly language programs generated by the assembler and “links” them together. There are three distinct steps involved in the linker’s role of computer translation:<\/p>\n

    \n
  1. Puts unique code into memory as symbolic references<\/li>\n
  2. Looks up addresses of data and instructions from the assembler files<\/li>\n
  3. Links the references of procedures and labels from many files to single places in memory<\/li>\n<\/ol>\n

    In simple terms, the linker ensures that the program doesn’t use duplicated code, where unnecessary and turns many parts into a single entity. One main benefit of the linker is that it allows only parts of the program having been changed since the last compilation to necessitate re-compilation.<\/p>\n

    Input<\/strong>: Assembled files and modules<\/p>\n

    Output<\/strong>: Executable file with completely resolved references<\/p>\n

    Loader<\/h2>\n

    The loader is responsible for\u00a0loading<\/em> the executable file into an operating system’s memory, completing the following sequence of actions:<\/p>\n

      \n
    1. Allocates required memory for text and data segments<\/li>\n
    2. Copies instructions and data from the linker’s executable file into memory<\/li>\n
    3. Copies parameters to the main<\/code> stack segment in memory<\/li>\n
    4. Initializes CPU registers and sets stack pointer to first free location<\/li>\n
    5. Copies parameters into appropriate CPU registers, begins execution of main<\/code> program, terminates on end.<\/li>\n<\/ol>\n

      Input<\/strong>: Executable File<\/p>\n

      Output<\/strong>: Depends on the program’s function<\/p>\n

      Discussion<\/h2>\n

      Each step in the translation of human-readable code to executable machine code serves an essential purpose. The encapsulation of processes within each step allows programmers from different disciplines and backgrounds to focus on discrete optimizations in ways that all other programmers can develop.<\/p>\n

      To get an idea of how this discretization of translation works; check out the GNU Compiler Collection (GCC)<\/a> which is an open-source project having spanned decades in open-source development. If you’re developing in C\u2014you’re probably already familiar with it!<\/p>\n

      Frequently Asked Questions<\/h2>\n

      What is Intermediate Code?<\/h3>\n

      Intermediate code, sometimes called intermediate representation (IR), is data structures or code that has been generated during the process of compilation. It represents a more efficient model of source code to assist during the assembly process. Examples of intermediate code include Java Byte Code, Microsoft’s Common Intermediate Language, and the C Intermediate Language.<\/p>\n","protected":false},"excerpt":{"rendered":"

      What happens when a computer program runs? What happens when a developer compiles a program? These are questions fundamental to the process of Computer translation and are essential in understanding how computers ingest human-friendly languages and turn them into machine code. Modern translation pipelines often make use of distributed systems like cloud-based solutions, dynamic link […]<\/p>\n","protected":false},"author":2,"featured_media":54,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"inline_featured_image":false,"footnotes":""},"categories":[1],"tags":[41,38,39,40,37],"acf":[],"_links":{"self":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/52"}],"collection":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/comments?post=52"}],"version-history":[{"count":5,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/52\/revisions"}],"predecessor-version":[{"id":423,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/52\/revisions\/423"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/media\/54"}],"wp:attachment":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/media?parent=52"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/categories?post=52"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/tags?post=52"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}