Cisco Career Certifications

Cisco Career Certifications are IT Professional certifications for Cisco Systems products. The tests are administered by Pearson VUE. There are five levels of certification: Entry, Associate, Professional, Expert, and Architect, as well as seven different paths, Routing & Switching, Design, Network Security, Service Provider, Storage Networking, Voice, and Wireless.

Online trading community

From Wikipedia, the free encyclopedia

Jump to: navigation, search

Part of a series on Electronic commerce

Online goods and services Streaming media Electronic books Software

Retail services Banking · Food ordering Online flower delivery · Blu-ray Disc or DVD rental Travel

Marketplace services Trading communities Auctions · Online wallet Advertising Price comparison service

E-procurement

Purchase-to-pay

This box: view • talk • edit

An online trading community provides participants with a structured method for trading, bartering, or selling goods and services. These communities often have forums and chatrooms designed to facilitate communication between the members. An online trading community can be likened electronic equivalent of a bazaar, flea market, or garage sale.

International domain name systems

The Domain Name System (DNS) is a hierarchical naming system for computers, services, or any resource connected to the Internet or a private network. It associates various information with domain names assigned to each of the participants. Most importantly, it translates domain names meaningful to humans into the numerical (binary) identifiers associated with networking equipment for the purpose of locating and addressing these devices worldwide. An often used analogy to explain the Domain Name System is that it serves as the "phone book" for the Internet by translating human-friendly computer hostnames into IP addresses. For example, www.example.com translates to 208.77.188.166.

MySQL: Using mysql in Batch Mode

In the previous sections, you used mysql interactively to enter queries and view the results. You can also run mysql in batch mode. To do this, put the commands you want to run in a file, then tell mysql to read its input from the file:

MySQL: Getting Information About Databases and Tables

What if you forget the name of a database or table, or what the structure of a given table is (for example, what its columns are called)? MySQL addresses this problem through several statements that provide information about the databases and tables it supports.
You have previously seen SHOW DATABASES, which lists the databases managed by the server. To find out which database is currently selected, use the DATABASE() function:

MySQL: Retrieving Information from a Table

The SELECT statement is used to pull information from a table. The general form of the statement is:

SELECT what_to_select
FROM which_table
WHERE conditions_to_satisfy;

what_to_select indicates what you want to see. This can be a list of columns, or * to indicate “all columns.” which_table indicates the table from which you want to retrieve data. The WHERE clause is optional. If it is present, conditions_to_satisfy specifies one or more conditions that rows must satisfy to qualify for retrieval.

MySQL: Loading Data into a Table

After creating your table, you need to populate it. The LOAD DATA and INSERT statements are useful for this.
Suppose that your pet records can be described as shown here. (Observe that MySQL expects dates in 'YYYY-MM-DD' format; this may be different from what you are used to.)

MySQL: Creating a Table

Creating the database is the easy part, but at this point it is empty, as SHOW TABLES tells you:

mysql> SHOW TABLES;
Empty set (0.00 sec)

The harder part is deciding what the structure of your database should be: what tables you need and what columns should be in each of them.
You want a table that contains a record for each of your pets. This can be called the pet table, and it should contain, as a bare minimum, each animal's name. Because the name by itself is not very interesting, the table should contain other information. For example, if more than one person in your family keeps pets, you might want to list each animal's owner. You might also want to record some basic descriptive information such as species and sex.

MySQL: Creating and Selecting a Database

If the administrator creates your database for you when setting up your permissions, you can begin using it. Otherwise, you need to create it yourself:

mysql> CREATE DATABASE menagerie;

MySQL: Access a database

Once you know how to enter commands, you are ready to access a database.
Suppose that you have several pets in your home (your menagerie) and you would like to keep track of various types of information about them. You can do so by creating tables to hold your data and loading them with the desired information. Then you can answer different sorts of questions about your animals by retrieving data from the tables. This section shows you how to perform the following operations:

MySQL: Entering Queries

Make sure that you are connected to the server, as discussed in the previous section. Doing so does not in itself select any database to work with, but that is okay. At this point, it is more important to find out a little about how to issue queries than to jump right in creating tables, loading data into them, and retrieving data from them. This section describes the basic principles of entering commands, using several queries you can try out to familiarize yourself with how mysql works.

MySQL:Connecting to and Disconnecting from the Server

To connect to the server, you will usually need to provide a MySQL user name when you invoke mysql and, most likely, a password. If the server runs on a machine other than the one where you log in, you will also need to specify a host name. Contact your administrator to find out what connection parameters you should use to connect (that is, what host, user name, and password to use). Once you know the proper parameters, you should be able to connect like this:

About MySQL

MySQL is the world's most popular open source database software, with over 100 million copies of its software downloaded or distributed throughout its history. With its superior speed, reliability, and ease of use, MySQL has become the preferred choice for Web, Web 2.0, SaaS, ISV, Telecom companies and forward-thinking corporate IT Managers because it eliminates the major problems associated with downtime, maintenance and administration for modern, online applications.
Many of the world's largest and fastest-growing organizations use MySQL to save time and money powering their high-volume Web sites, critical business systems, and packaged software — including industry leaders such as Yahoo!, Alcatel-Lucent, Google, Nokia, YouTube, Wikipedia, and Booking.com.

C++: STL (Standard Template Library)

The container manages the storage space for its elements and provides member functions to access them, either directly or through iterators (reference objects with similar properties to pointers).

Containers replicate structures very commonly used in programming: dynamic arrays (vector), queues (queue), stacks (stack), heaps (priority_queue), linked lists (list), trees (set), associative arrays (map)...

History of Computer #4

The title of forefather of today's all-electronic digital computers is usually awarded to ENIAC, which stood for Electronic Numerical Integrator and Calculator. ENIAC was built at the University of Pennsylvania between 1943 and 1945 by two professors, John Mauchly and the 24 year old J. Presper Eckert, who got funding from the war department after promising they could build a machine that would replace all the "computers", meaning the women who were employed calculating the firing tables for the army's artillery guns. The day that Mauchly and Eckert saw the first small piece of ENIAC work, the persons they ran to bring to their lab to show off their progress were some of these female computers (one of whom remarked, "I was astounded that it took all this equipment to multiply 5 by 1000").

History of Computer #3

IBM continued to develop mechanical calculators for sale to businesses to help with financial accounting and inventory accounting. One characteristic of both financial accounting and inventory accounting is that although you need to subtract, you don't need negative numbers and you really don't have to multiply since multiplication can be accomplished via repeated addition.

History of Computer #2

Just a few years after Pascal, the German Gottfried Wilhelm Leibniz (co-inventor with Newton of calculus) managed to build a four-function (addition, subtraction, multiplication, and division) calculator that he called the stepped reckoner because, instead of gears, it employed fluted drums having ten flutes arranged around their circumference in a stair-step fashion. Although the stepped reckoner employed the decimal number system (each drum had 10 flutes), Leibniz was the first to advocate use of the binary number system which is fundamental to the operation of modern computers. Leibniz is considered one of the greatest of the philosophers but he died poor and alone.

Leibniz's Stepped Reckoner (have you ever heard "calculating" referred to as "reckoning"?)

History of Computer #1

The first computers were people! That is, electronic computers (and the earlier mechanical computers) were given this name because they performed the work that had previously been assigned to people. "Computer" was originally a job title: it was used to describe those human beings (predominantly women) whose job it was to perform the repetitive calculations required to compute such things as navigational tables, tide charts, and planetary positions for astronomical almanacs. Imagine you had a job where hour after hour, day after day, you were to do nothing but compute multiplications. Boredom would quickly set in, leading to carelessness, leading to mistakes. And even on your best days you wouldn't be producing answers very fast. Therefore, inventors have been searching for hundreds of years for a way to mechanize (that is, find a mechanism that can perform) this task.

This picture shows what were known as "counting tables" [photo courtesy IBM]

History of C++ programming language

During the 60s, while computers were still in an early stage of development, many new programming languages appeared. Among them, ALGOL 60, was developed as an alternative to FORTRAN but taking from it some concepts of structured programming which would later inspire most procedural languages, such as CPL and its succesors (like C++). ALGOL 68 also directly influenced the development of data types in C. Nevertheless ALGOL was an non-specific language and its abstraction made it impractical to solve most commercial tasks.

History of C programming language

Historically, C was developed at Bell Laboratories as a system programming language to implement a new operating system on a DEP PDP-11 minicomputer. The project began in 1972, and a language description was published six years later (Kernighan and Ritchie, 1978) [C is a compact terse programming language that includes data types, data separations, the ability to manipulate addresses, and uncomplicated but complete set of flow control constructions.

History of Linux: Timeline of Linux History

Here is timeline table of Linux History.

History of Linux: Some Linux Cookies

Here are some famous words by Linus himself.

History of Linux: Tux the penguin - Linux's Dear Logo

The logo of Linux is a penguin. Unlike other commercial products of computer operating systems, Linux doesn't have a formidable serious looking symbol. Rather Tux, as the penguin is lovingly called, symbolizes the carefree attitude of the total movement. This cute logo has a very interesting history. As put forward by Linus, initially no logo was selected for Linux. Once Linus went to the southern hemisphere on a vacation. There he encountered a penguin, not unlike the current logo of Linux. As he tried to pat it, the penguin bit his hand. This amusing incident led to the selection of a penguin as the logo of Linux sometime later.

History of Linux: After a Decade - Linux Today

Proving all the warning and prophecies of the skeptics wrong, Linux has completed a decade of development. Today, Linux is one of the fastest growing operating systems in the history. From a few dedicated fanatics in 1991-92 to millions of general users at present, it is certainly a remarkable journey. The big businesses have 'discovered' Linux, and have poured millions of dollars into the development effort, denouncing the anti-business myth of the open-source movement. IBM corp. once considered the archenemy of open-source hacker community, has come forward with a huge fund for development of open source Linux based solutions. But what's really amazing is the continuously increasing band of developers spread throughout the world who work with a fervent zeal to improve upon the features of Linux. The development effort is not, as many closed-sourced advocates accuse, totally engulfed with chaos. A well designed development model supervised by some maintainers is adopted. Along with this, there are thousands of developers working to port various applications to Linux.

History of Linux: Confrontation & Development

Linus displays Linux running on a notebook pc

Soon Linus faced some confrontation from none other than Andrew Tanenbaum, the great teacher who wrote MINIX. In a post to Linus, Tanenbaum commented:

History of Linux: New Baby in the Horizon

In 1991, Linux Benedict Torvalds was a second year student of Computer Science at the Univeristry of Helinsks and a self-taught hacker. The 21 year old sandy haired soft-spoken Finn loved to tinker with the power of the computers and the limits to which the system can be pushed. But all that was lacking was an operating system that could meet the demands of the professionals. MINIX was good, but still it was simply an operating system for the students, designed as a teaching tool rather than an industry strength one.

History of Linux: In The Beginning

It was 1991, and the ruthless agonies of the cold war were gradually coming to an end. There was an air of peace and tranquility that prevailed in the horizon. In the field of computing, a great future seemed to be in the offing, as powerful hardware pushed the limits of the computers beyond what anyone expected.

But still, something was missing.

And it was the none other than the Operating Systems, where a great void seemed to have appeared.

Linux philosophy: Cooperation vs. Competition

This is the second article in a series exploring the philosophy of free software. The first, entitled The Beauty of Doubt and published in the February 99 issue, covered the concept of doubt, and discussed the improbability that good software can be developed if one does not have the ability to doubt that one's code, work, theory, or whatever may be flawed. The arrogance that a final product is unimprovable is something rarely if ever seen in the free software community (FSC). This allows for the continued improvement that we all see, and for the quick reaction to problems.

Linux philosophy: The Beauty of Doubt

Nearly every article that I have read in The Linux Gazette has been technical and/or practical, so let me apologize if this seems a bit "off topic." I am primarily an anthropologist, and as such have always been a bit more inclined to write about things more generally. Instead of the technical and practical, I want to wax philosophic for a bit on the subject of free software in general, and the Linux kernel in particular by "porting" a bit of my philosophy of life to the computer. I have tried to write these articles for both the newcomers to the Free Software Community (FSC) as well as for those who have been around a lot longer than I. I will not waste time on the definition of free software except to say that it is free as in freedom. For a definition, I would have the reader visit the GNU/Free Software Foundation website. The few facts that I intend to present will only be news to those unfamiliar with free software, while the philosophy- at least as seen from my vantage- will probably be new to all. My idea is to present what for the lack of a better term I call The Four Cornerstones to the Foundation of Free Software. These are the four main things that I consider vital to the Free Software Movement (FSM) in general, and to the Linux kernel in particular. They are, in no particular order: Doubt, cooperation, non-control (read: Freedom), and rebellion. I have chosen to break these up into a series, because it would be a bit long as one article. In each case, I will give an explanation of what I mean by the idea and an example of how it pertains to the FSM. I also offer the opportunity for discussion/argumentation if anyone cares to explore "Free Philosophy" further. To those few I invite the use of my email address at the beginning of these articles.

SPIM print example

# This program takes input from the user and echoes it back

.data
# Constant strings to be output to the terminal
promptInt: .asciiz "Please input an integer: "
resultInt: .asciiz "Next integer is: "
linefeed: .asciiz "\n"
enterkey: .asciiz "Press any key to end program."
.text
main:
# prompt for an integer
li $v0,4 # code for print_string
la $a0,promptInt # point $a0 to prompt string
syscall # print the prompt
# get an integer from the user
li $v0,5 # code for read_int
syscall #get int from user --> returned in $v0
move $t0,$v0 # move the resulting int to $t0
# compute the next integer
addi $t0, $t0, 1 # t0 <-- t0 + 1
# print out text for the result
li $v0,4 #code for print_string
la $a0,resultInt # point $a0 to result string
syscall # print the result string
# print out the result
li $v0,1 # code for print_int
move $a0,$t0 # put result in $a0
syscall # print out the result
# print out a line feed
li $v0,4 # code for print_string
la $a0,linefeed # point $a0 to linefeed string
syscall # print linefeed
# wait for the enter key to be pressed to end program
li $v0,4 # code for print_string
la $a0,enterkey # point $a0 to enterkey string
syscall # print enterkey
# wait for input by getting an integer from the user (integer is ignored)
li $v0,5 # code for read_int
syscall #get int from user --> returned in $v0
# All done, thank you!
li $v0,10 # code for exit
syscall # exit program

Registers

By convention, many MIPS registers have special purpose uses. To help clarify this, SPIM defines aliases for each register that represent its purpose. The following table lists these aliases and the commonly accepted uses for the registers.

Register	Number	Usage
zero	0	Constant 0
at	1	Reserved for assembler
v0	2	Used for return values  from function calls.
v1	3
a0	4	Used to pass arguments to  procedures and functions.
a1	5
a2	6
a3	7
t0	8	Temporary (Caller-saved, need  not be saved by called procedure)
t1	9
t2	10
t3	11
t4	12
t5	13
t6	14
t7	15
s0	16	Saved temporary (Callee-saved,  called procedure must save and restore)
s1	17
s2	18
s3	19
s4	20
s5	21
s6	22
s7	23
t8	24	Temporary (Caller-saved, need not  be saved by called procedure)
t9	25
k0	26	Reserved for OS kernel
k1	27
gp	28	Pointer to global area
sp	29	Stack pointer
fp	30	Frame pointer
ra	31	Return address for function calls.

SPIM Instruction Set

This document gives an overview of the more common instructions used in the SPIM simulator. See Appendix A of Computer Organization and Design by Hennessy and Patterson for more details.

Overview

The SPIM simulator implements the full MIPS instruction set, as well as a large number of pseudoinstructions that correspond to one or more equivalent MIPS instructions. There are also a small number of system call commands used to interface with the console window of the SPIM simulator. Finally, SPIM renames registers according to commonly used conventions in order to facilitate the readability of programs.

Instructions and PseudoInstructions

The following is an abbreviated list of MIPS instructions and SPIM pseudoinstructions. This list is not complete. Notably missing are all Floating Point and coprocessor instructions.

• - Indicates an actual MIPS instruction. Others are SPIM pseudoinstructions.

Instruction Function

• add Rd, Rs, Rt Rd = Rs + Rt (signed)

• addu Rd, Rs, Rt Rd = Rs + Rt (unsigned)

• addi Rd, Rs, Imm Rd = Rs + Imm (signed)

• sub Rd, Rs, Rt Rd = Rs - Rt (signed)

• subu Rd, Rs, Rt Rd = Rs - Rt (unsigned)

• div Rs, Rt lo = Rs/Rt, hi = Rs mod Rt (integer division, signed)

• divu Rs, Rt lo = Rs/Rt, hi = Rs mod Rt (integer division, unsigned)

div Rd, Rs, Rt Rd = Rs/Rt (integer division, signed)

divu Rd, Rs, Rt Rd = Rs/Rt (integer division, unsigned)

rem Rd, Rs, Rt Rd = Rs mod Rt (signed)

remu Rd, Rs, Rt Rd = Rs mod Rt (unsigned)

mul Rd, Rs, Rt Rd = Rs * Rt (signed)

• mult Rs, Rt hi, lo = Rs * Rt (signed, hi = high 32 bits, lo = low 32 bits)

• multu Rd, Rs hi, lo = Rs * Rt (unsigned, hi = high 32 bits, lo = low 32 bits)

• and Rd, Rs, Rt Rd = Rs • Rt

• andi Rd, Rs, Imm Rd = Rs • Imm

neg Rd, Rs Rd = -(Rs)

• nor Rd, Rs, Rt Rd = (Rs + Rt)’

not Rd, Rs Rd = (Rs)’

• or Rd, Rs, Rt Rd = Rs + Rt

• ori Rd, Rs, Imm Rd = Rs + Imm

• xor Rd, Rs, Rt Rd = Rs ⊕ Rt

• xori Rd, Rs, Imm Rd = Rs ⊕ Imm

• sll Rd, Rt, Sa Rd = Rt left shifted by Sa bits

• sllv Rd, Rs, Rt Rd = Rt left shifted by Rs bits

• srl Rd, Rs, Sa Rd = Rt right shifted by Sa bits

• srlv Rd, Rs, Rt Rd = Rt right shifted by Rs bits

move Rd, Rs Rd = Rs

• mfhi Rd Rd = hi

• mflo Rd Rd = lo

li Rd, Imm Rd = Imm

• lui Rt, Imm Rt[31:16] = Imm, Rt[15:0] = 0

• lb Rt, Address(Rs) Rt = byte at M[Address + Rs] (sign extended)

• sb Rt, Address(Rs) Byte at M[Address + Rs] = Rt (sign extended)

• lw Rt, Address(Rs) Rt = word at M[Address + Rs]

• sw Rt, Address(Rs) Word at M[Address + Rs] = Rt

• slt Rd, Rs, Rt Rd = 1 if Rs < Rt, Rd = 0 if Rs ≥ Rt (signed)

• slti Rd, Rs, Imm Rd = 1 if Rs < Imm, Rd = 0 if Rs ≥ Imm (signed)

• sltu Rd, Rs, Rt Rd = 1 if Rs < Rt, Rd = 0 if Rs ≥ Rt (unsigned)

• beq Rs, Rt, Label Branch to Label if Rs == Rt

beqz Rs, Label Branch to Label if Rs == 0

bge Rs, Rt, Label Branch to Label if Rs ≥ Rt (signed)

• bgez Rs, Label Branch to Label if Rs ≥ 0 (signed)

• bgezal Rs, Label Branch to Label and Link if Rs ≥ Rt (signed)

bgt Rs, Rt, Label Branch to Label if Rs > Rt (signed)

bgtu Rs, Rt, Label Branch to Label if Rs > Rt (unsigned)

• bgtz Rs, Label Branch to Label if Rs > 0 (signed)

ble Rs, Rt, Label Branch to Label if Rs ≤ Rt (signed)

bleu Rs, Rt, Label Branch to Label if Rs ≤ Rt (unsigned)

• blez Rs, Label Branch to Label if Rs ≤ 0 (signed)

• bgezal Rs, Label Branch to Label and Link if Rs ≥ 0 (signed)

• bltzal Rs, Label Branch to Label and Link if Rs < 0 (signed)

blt Rs, Rt, Label Branch to Label if Rs < Rt (signed)

bltu Rs, Rt, Label Branch to Label if Rs < Rt (unsigned)

• bltz Rs, Label Branch to Label if Rs < 0 (signed)

• bne Rs, Rt, Label Branch to Label if Rs ≠ Rt

bnez Rs, Label Branch to Label if Rs ≠ 0

• j Label Jump to Label unconditionally

• jal Label Jump to Label and link unconditionally

• jr Rs Jump to location in Rs unconditionally

• jalr Label Jump to location in Rs and link unconditionally 

System Calls

In order to perform I/O with the console, SPIM provides a small library of system calls. In general, system calls are set up by placing a system call in register $v0, and any arguments in register $a0 and $a1. Returned values are placed in register $v0. See the table and the example program below for usage.

Service	System Call Code	Arguments	Result
Print_int	1	$a0 = integer
Print_float	2	$f12 = float
Print_double	3	$f12 = double
Print_string	4	$a0 = string
Read_int	5		Integer (in $v0)
Read_float	6		Float (in $f0)
Read_double	7		Double (in $f0)
Read_string	8	$a0 = buffer, $a1 = length
Sbrk	9	$a0 = amount	Address (in $v0)
exit	10

# This program takes input from the user and echoes it back

.data

# Constant strings to be output to the terminal

promptInt: .asciiz "Please input an integer: "

resultInt: .asciiz "Next integer is: "

linefeed: .asciiz "\n"

enterkey: .asciiz "Press any key to end program."

.text

main:

# prompt for an integer

li $v0,4 # code for print_string

la $a0,promptInt # point $a0 to prompt string

syscall #print the prompt

# get an integer from the user

li $v0,5 # code for read_int

syscall #get int from user --> returned in $v0

move $t0,$v0 # move the resulting int to $t0

# compute the next integer

addi $t0, $t0, 1 # t0 <-- t0 + 1

# print out text for the result

li $v0,4 #code for print_string

la $a0,resultInt # point $a0 to result string

syscall # print the result string

# print out the result

li $v0,1 # code for print_int

move $a0,$t0 # put result in $a0

syscall # print out the result

# print out a line feed

li $v0,4 # code for print_string

la $a0,linefeed # point $a0 to linefeed string

syscall # print linefeed

# wait for the enter key to be pressed to end program

li $v0,4 # code for print_string

la $a0,enterkey # point $a0 to enterkey string

syscall # print enterkey

# wait for input by getting an integer from the user (integer is ignored)

li $v0,5 # code for read_int

syscall #get int from user --> returned in $v0

# All done, thank you!

li $v0,10 # code for exit

syscall # exit program

Instruction

In computer science, an instruction is a single operation of a processor defined by an instruction set architecture. In a broader sense, an "instruction" may be any representation of an element of an executable program, such as a bytecode.
On traditional architectures, an instruction includes an opcode specifying the operation to be performed, such as "add contents of memory to register", and zero or more operand specifiers, which may specify registers, memory locations, or literal data. The operand specifiers may have addressing modes determining their meaning or may be in fixed fields.

Operand

An operand is a quantity on which an operation is performed. The following arithmetic expression shows an example of operators and operands:

3 + 6 = 9

In the above example, '+' is the symbol for the operation called addition. The operand '3' is one of the inputs (quantities) followed by the addition operator, and the operand '6' is the other input necessary for the operation. The result of the operation is 9. (The number '9' is also called the sum of the addend, 3 and 6.)

An operand, then, is also referred to as "one of the inputs (quantities) for an operation".

Illegal opcode

An Illegal Opcode, also called an Undocumented Instruction, is an instruction to a CPU that is not mentioned in any official documentation released by the CPU's designer or manufacturer, which nevertheless has an effect. Illegal opcodes were common on older CPUs designed during the 1970s, such as the MOS Technology 6502, Intel 8086 and the Zilog Z80. They exist as a side-effect of the wiring of transistors in the CPU, and usually combine functions of the CPU that were not intended to be combined.

Opcode

In computer technology, an opcode (operation code) is the portion of a machine language instruction that specifies the operation to be performed. Their specification and format are laid out in the instruction set architecture of the processor in question (which may be a general CPU or a more specialized processing unit). Apart from the opcode itself, an instruction normally also has one or more specifiers for operands (i.e. data) on which the operation should act, although some operations may have implicit operands, or none at all. There are instruction sets with nearly uniform fields for opcode and operand specifiers, as well as others (the x86 architecture for instance) with a more complicated, varied length structure.
Depending on architecture, the operands may be register values, values in the stack, other memory values, I/O ports, etc, specified and accessed using more or less complex addressing modes. The types of operations include arithmetics, data copying, logical operations, and program control, as well as special instructions (such as CPUID and others).

Typed Assembly language

In computer science, a typed assembly language (TAL) is an assembly language that is extended to include a method of annotating the datatype of each value that is manipulated by the code. These annotations can then be used by a program (type checker) that processes the assembly language code in order to analyse how it will behave when it is executed. Specifically, such a type checker can be used to prove the type safety of code that meets the criteria of some appropriate type system.
Typed assembly languages usually include a high-level memory management system based on a garbage collection.
A typed assembly language with a suitably expressive type system can be used to enable the safe execution of untrusted code without using an intermediate representation like bytecode, allowing features similar to those currently provided by virtual machine environments like Java and .NET.

Instruction set

An instruction set is a list of all the instructions, and all their variations, that a processor (or in the case of a virtual machine, an interpreter) can execute.
Instructions include:
Arithmetic such as add and subtract
Logic instructions such as and, or, and not
Data instructions such as move, input, output, load, and store
Control flow instructions such as goto, if ... goto, call, and return.
An instruction set, or instruction set architecture (ISA), is the part of the computer architecture related to programming, including the native data types, instructions, registers, addressing modes, memory architecture, interrupt and exception handling, and external I/O. An ISA includes a specification of the set of opcodes (machine language), the native commands implemented by a particular processor.
Instruction set architecture is distinguished from the microarchitecture, which is the set of processor design techniques used to implement the instruction set. Computers with different microarchitectures can share a common instruction set. For example, the Intel Pentium and the AMD Athlon implement nearly identical versions of the x86 instruction set, but have radically different internal designs.
This concept can be extended to unique ISAs like TIMI (Technology-Independent Machine Interface) present in the IBM System/38 and IBM AS/400. TIMI is an ISA that is implemented as low-level software and functionally resembles what is now referred to as a virtual machine. It was designed to increase the longevity of the platform and applications written for it, allowing the entire platform to be moved to very different hardware without having to modify any software except that which comprises TIMI itself. This allowed IBM to move the AS/400 platform from an older CISC architecture to the newer POWER architecture without having to recompile any parts of the OS or software associated with it. Nowadays there are several open source Operating Systems which could be easily ported on any existing general purpose CPU, because the compilation is the essential part of their design (e.g. new software installation).

Assembly language

Assembly languages are a family of low-level languages for programming computers, microprocessors, microcontrollers, and other (usually) integrated circuits. They implement a symbolic representation of the numeric machine codes and other constants needed to program a particular CPU architecture. This representation is usually defined by the hardware manufacturer, and is based on abbreviations (called mnemonics) that help the programmer remember individual instructions, registers, etc. An assembly language is thus specific to a certain physical or virtual computer architecture (as opposed to most high-level languages, which are usually portable).
A utility program called an assembler is used to translate assembly language statements into the target computer's machine code. The assembler performs a more or less isomorphic translation (a one-to-one mapping) from mnemonic statements into machine instructions and data. This is in contrast with high-level languages, in which a single statement generally results in many machine instructions.
Many sophisticated assemblers offer additional mechanisms to facilitate program development, control the assembly process, and aid debugging. In particular, most modern assemblers include a macro facility (described below), and are called macro assemblers.

Information technology

Information technology (IT), as defined by the Information Technology Association of America (ITAA), is "the study, design, development, implementation, support or management of computer-based information systems, particularly software applications and computer hardware."[1] IT deals with the use of electronic computers and computer software to convert, store, protect, process, transmit, and securely retrieve information.

Hello World!!!

I just created this blog. I hope you enjoy my posts ^ ^