Assembler Programming language :: Assembly

Assembler Programming language

"C isn't that hard: void (*(*f)) defines f as an array of unspecified size, of pointers to functions that return pointers to functions that return void"

"C++ is a write-only language, one can write programs in C++, but I can't read any of them"

Computers, for the most part, are dumb. If you were to take computer hardware that was freshly built off the assembly line, put the components together into a fully assembled device, and tried to turn it on, it wouldn't do anything useful (if anything at all). Yes, Windows and Mac OS don't magically appear in the computer right from the factory. But if you give them something to do, they'll be able to do it really fast! But how do you tell a machine what to do? Here comes the programming language. As the name implies, it's the language you use to program the computer to do what you want. While there are other "languages" that may tell a computer what to do, there are defining points between them all.
  • Programming languages, according to The Other Wiki, describes programs. Basically any task that was meant for calculating, controlling the behavior of the machine directly, or offering a human-friendly interface.
  • Scripting languages typically control programs to do other things as an extension. For example, JavaScript can tell a web browser to do an animation, swap icons on a mouse hover, or do popups. You could not however, run the JavaScript source by itself.
  • Markup languages such as HTML and XML describe how a document should look. Akin to "marking up" a paper in editing before finalizing it. This is what you'll see when you hit the "Edit page" button on This Very Wiki.

Concepts

A programming language has four basic elements to it:
  • Symbols to hold data.
  • Operators that modify the data.
  • Conditional statements that control the flow of the program.
  • The ability to jump around in the program at will.
Programs are written into source files, which can be compiled or assembled for later execution, or interpreted for execution right away. If there's something immediately wrong with the source file, the compiler, assembler, or interpreter will complain until it's fixed. It should also be noted that a computer is more or less a Literal Genie. It's very, very rare a computer makes a mistake because it actually made a mistake. It "makes mistakes" because of how the program was written. Thus, there is an artistic side of programming.

Low Level Languages

At its heart, a computer is a giant calculator that computes arithmetic billions of times per second. All of its constituent parts, from memory to modem to monitor to mouse, has an alphanumerical address associated with it. The computer uses these addresses to route data throughout itself. Hence, the earliest computer languages evolved to reflect how computers fundamentally worked. An extraordinarily simple instruction might be "Take the number stored at memory address X and subtract it from the number stored at memory address Y, then send it to the printer located at hardware address Z". Low level languages use hardware-specific instructions to talk directly to the computer this way. A programmer can write a low level source code in two ways:
  • Machine code: The most barebone programming ever. This is literally writing the 0's and 1's or more commonly their hexadecimal equivalents. There's usually two portions to a machine code, the operation code (opcode), which is the instruction, and the operand(s), which is the datum or data that act on this instruction. Computers until The Fifties had to be programmed like this.
  • Assembly code: The next step in the language development introduced in The Fifties. Opcodes and some special operands are now given more human readable mnemonics but often kept to very abbreviated words. But this allowed certain features like labels that allowed sections of memory to have a name, getting rid of the tedious job of keeping track of where one was in memory. Assembly code is machine specific, and one cannot assume one mnemonic means the same exact operation in another machine.
The reason for using low level languages is for maximum performance and maximum flexibility. The code that's written is directly talking to hardware and the programmer has full access (barring specific security features) to the hardware. The tradeoff is that it's very easy to write code that breaks the system in software and a lack of portability. It's unusual these days to write assembly code by hand, because compilers have gotten so good at optimizing slightly higher-level languages like C. So languages are sometimes termed "low-level" because they give you a lot of control over how the assembly code turns out. In addition, many modern compilers actually allow programmers to create the assembler "inserts" in the high-level source code. Some languages (such as Forth) are "multi-level" and allow both low-level and high-level coding to be done in the same syntax, and sometimes the same program.

High Level Languages

High level languages translate assembly code into something easily human-readable and automate the more mind-numbing parts. For example, you could write "x = 2" instead of "MOV x, 2" or "for(5: Array)" instead of manually looping through instructions. However, this sacrifices performance and (arguably) flexibility because the computer must parse the instructions and translate them into machine code. More abstracted high level languages go further, replacing, say, "x = 2" with "x is 2". Complex languages are created with earlier ones, "standing on the shoulders of giants"; a compiler is essentially a text parser that goes through source code for a given language and translates it into whatever language the compiler was written in. Along with readability, high level languages also allow for "portability" as long as a compiler or interpreter exists for the platform. Some high level languages are dubbed mid level languages, meaning the language is closer to assembly. A mid level language can directly manipulate the computer's memory and input/output devices. Higher level languages are instead sealed off from the hardware and must interface with a program (usually the part of an operating system called the kernel) written in a mid level or low level language that then interacts with the hardware and memory. Consequently, higher level languages like Java cannot be used to write operating systems or hardware drivers unassisted and often perform slower than mid level languages like the near-ubiquitous C and C++ (which Java was written in). Source files can be executed in three different ways:
  • Ahead Of Time Compiling (AOT): This turns the source code into an executable that can be loaded into memory and ran without further processing. This has the fastest execution time, but can limit your software distribution if you need to have it run on other architectures.
  • Just-in-Time Compiling (JIT): Some of the source is compiled into executable code for the computer architecture when it's needed (hence, just-in-time). While it can be as fast as AOT and can run on more platforms (assuming the JIT system is available for it), it's usually more resource intensive.
  • Interpreting: This will turn the source code into executable code essentially line by line. While it's quite slow and resource hungry, it can be run as is.
Programming can be thought of as making a recipe for a dish. For instance, making a cake:

You might also like

Assembly Language Programming Tutorial - 1 - Installing
Assembly Language Programming Tutorial - 1 - Installing ...
Assembly Language Programming Tutorial 65 The UNIX Assembler
Assembly Language Programming Tutorial 65 The UNIX Assembler
LWW Computers LWW ipazzport KP-810-19 Germany + English Language Mini Wireless 2.4GHz 84-Keys Keyboard - Black
PC Accessory (LWW Computers)
  • Expedited Shipping Time 6-9 Days .
  • Standard Shipping Time 15-25 days.
  • Ships from HongKong .
  • Ship By Airmail With Online Tracking Information .
  • If you have any questions, please feel free to contact me .
Your Inner Geek, LLC C Programming with The Programmable Box (Orange-Kit)
Software (Your Inner Geek, LLC)
  • This is the first in a series of educational products that teach C Programming using The Programmable Box
  • Ages 10+, home schooling, classroom instruction, self paced instruction, computer clubs, science projects
  • A fun step-by-step approach where students write interesting programs using The Programmable Box which contains LED s, buzzer, range detector, and other input/output...
  • Extensive step-by-step manual (.pdf), Arduna Nano compatible processor, ultra-sonic range detector, buzzer, 6 colored LED s, potentiometer, momentary contact switch...
  • This is the kit version (also available fully assembled). Visit .your-inner-geek.com for complete curriculum included in instruction manual. 100% Satisfaction guaranteed...

Copyright © . All Rights Reserved