Layers of Representation of Machine Structures

-

Layers of representation (high to low level)

  1. High-level language program 
    • high-level language - a programming language that uses English and mathematical symbols in its instructions (e.g. C) 
      • High-level programming languages are abstractions to lower-level programming languages 
  2. compiler - turns high-level language problem into an assembly language program
  3. Assembly language program 
    • assembly language - a low-level programming language for a computer in which there is a strong correspondence between the language and the architecture's machine code instructions (e.g. MIPS, x86, 32b ARM) 
      • Assembly languages are abstractions of machine languages 
      • Assembly code is human-readable version of computer's native machine code 
      • There are different assembly languages for different CPUs following different ISAs (each assembly language is tied to a particular ISA) 
  4. assembler - turns assembly language program into machine language program
  5. Machine Language Program (MIPS) 
    • machine language (machine code) - a low-level programming language that consists of bits (0s and 1s) and is the only language that is directly understood by the computer 
  6. Machine interpretation
  7. Hardware Architecture Description (e.g. block diagrams) 
    • hardware architecture - refers to the identification of a system's physical components and their interrelationships 
  8. Architecture implementation
  9. Logic circuit description (circuit schematic diagrams)

High-level vs. low-level programming languages

  • Low-level languages 

    • In a low-level language, the programmer is most aware of how the particular computer that is being used works 
      • The programmer has more control over the precise way the computer carries out a computation 
    • Low-level languages are best for tasks in which knowledge of hardware is part of the problem itself (e.g. operating systems, compilers) 
    • Low-level language generally refers to assembly language or machine code 
    • Low-level languages can convert to machine code without a compiler or interpreter 

  • High-level languages 

    • In a high-level language, the programmer works at a higher level of abstraction 
      • The programmer needs to know less about how the computer actually performs tasks 
      • The programmer focuses more about how the problem is being solved 
    • High-level languages are best for writing application programs (e.g. word processor, web browser, etc.) 
    • Ex. Java, Python, Go, Ruby



Other helpful articles






Comments

Post a Comment

Popular posts from this blog

AI Search Problems Overview

-
Image
What is an agent? agent - an entity that perceives and acts planning agent - an agent that make decisions based on (hypothesized) consequences of actions Planning agents simulate situations and performs/executes the best action according to its simulations done in the "planning" stage Planning agents consider how the world would be Planning agents must have a model of how the world evolves in response to actions Planning agents must formulate a goal (test) Planning agents are complete (i.e. they never get stuck and always find a solution, since the plan ahead) The agent does not actually perform all the plans out in the real world The planning is all done "in simulation" search agent - a planning agents that solves search problems Search problems search problem - a type of planning problem with the four components (listed below); the environment in which a rational planning agent exists in Search operates over models of the real world
Read more

Tips on Pointers and Arrays in C

-
Image
*p++ vs. (*p)++   *p++ means *(p++) ++ binds to p , not to *p ++ will increment "p," not "*p," which is the thing that "p" points to The value of the expression *p++ is the value that p pointed to before being incremented ( *p ) Two useful charts Pointer arithmetic notes (~pointer~) += (~number~);  means  (~pointer~) += ~number~) * sizeof((~type~)); Pointer arithmetic addition adds multiples of the type size to the memory address Ex. If p is a pointer to an integer, then p += 1 means p += 1 * sizeof(int)   (~pointer name~) + 1 points to the next object in memory (returns a pointer to the next element)  (~pointer name~) + i points to the i -th object beyond (~pointer name~) in memory  (~pointer name~) += i increments (~pointer name~) to point to i elements beyond itself  Types of valid pointer arithmetic Adding an integer to a pointer Subtracting 2 pointers (in the same array) Comparing poi
Read more

Standard/Planning Search Problems

-
Image
Standard search problems Solution to a standard search problem: a plan Use a search algorithm  to find the plan and solve the search problem Search algorithms are performed on the search tree (of the problem) to find the solution to the search problem All search algorithms follow the same algorithm, but just use a different data structures for the fringe   Types of standard searches ➤  UNINFORMED SEARCH uninformed search  - a search that does not know information about the goal's location Types of uninformed searches Depth first search (DFS) - a search strategy that expands the deepest node first Implementation : uses a last-in-first-out (LIFO)  stack as the fringe Time complexity : $O(b^m)$, for a finite tree where $m$ is the maximum depth and $b$ is the branching factor Space complexity : $O(bm)$ DFS expands only the nodes on a single path from the deepest level to the root Breadth first search (BFS) - a search strategy in which the root is ex
Read more