what is programming language

 programming language

A vocabulary and set of grammatical rules for instructing a computer to perform specific tasks. The term programming language usually refers to high-level languages, such as BASIC, C, C++, COBOL, FORTRAN, Ada, and Pascal. Each language has a unique set of keywords (words that it understands) and a special syntax for organizing program instructions.High-level programming languages, while simple compared to human languages, are more complex than the languages the computer actually understands, called machine languages. Each different type of CPU has its own unique machine language.
A programming language is typically divided into two elements: syntax and semantics. There is pretty much always a specification document to define both elements. For example, an ISO standard defines C, while Perl has a dominant implementation used as a reference.

Add caption

An algorithm is described using the programming language. Programming languages are typically called computer languages; however, some authors deem programming languages to be subsets of computer languages. Since the oldest forms of programming languages like COBOL and FORTRAN, thousands of computer languages have been developed. 

kinds of programing language

1. computer science, computing - the branch of engineering science that studies (with the aid of computers) computable processes and structures
2. artificial language - a language that is deliberately created for a specific purpose
3. algorithmic language - an artificial language designed to express algorithms
4. assembly language - a low-level programing language; close approximation to machine language
5. computer language, computer-oriented language, machine language, machine-oriented language - a programming language designed for use on a specific class of computers
6. multidimensional language - a programming language whose expressions are assembled in more than one dimension
7. object language, target language - a computer language into which something written in another computer language is to be translated
8. object-oriented programing language, object-oriented programming language - (computer science) a programming language that enables the programmer to associate a set of procedures with each type of data structure; "C++ is an object-oriented programming language that is an extension of C"
9. one-dimensional language - a programming language whose expressions are represented by strings of characters
10. stratified language - a language that cannot be used as its own metalanguage
11. unstratified language - a programming language that (like natural language) can be used as its own metalanguage
12. list-processing language, LISP - a flexible procedure-oriented programing language that manipulates symbols in the form of lists
13. logic programing, logic programming, Prolog - a computer language designed in Europe to support natural language processing
14. COBOL - common business-oriented language
15. C - a general-purpose programing language closely associated with the UNIX operating system
16. BASIC - a popular programming language that is relatively easy to learn; an acronym for beginner's all-purpose symbolic instruction code; no longer in general use
17. Pascal - a programing language designed to teach programming through a top-down modular approach

Classifying Programming Languages

Different languages have different purposes, so it makes sense to talk about different kinds, or types, of languages. Some types are:

• Machine languages — interpreted directly in hardware
• Assembly languages — thin wrappers over a corresponding machine language
• High-level languages — anything machine-independent
• System languages — designed for writing low-level tasks, like memory and process management
• Scripting languages — generally extremely high-level and powerful
• Domain-specific languages — used in highly special-purpose areas only
• Visual languages — non-text based
• Esoteric languages — not really intended to be used

Machine Code

Most computers work by executing stored programs in a fetch-execute cycle. Machine code generally features

• Registers to store values and intermediate results
• Very low-level machine instructions (add, sub, div, sqrt)
• Labels and conditional jumps to express control flow
• A lack of memory management support — programmers do that themselves

Machine code is usually written in hex. Example for the Intel 64 architecture:

89 F8 A9 01 00 00 00 75 06 6B C0
03 FF C0 C3 C1 E0 02 83 E8 03 C3

Assembly Language

An assembly language is basically just a simplistic encoding of machine code into something more readable. It does add labeled storage locations and jump targets and subroutine starting addresses, but not much more. Here's the function on the Intel 64 architecture using the GAS assembly language:

        .globl  f

        .text

f:

        mov     %edi, %eax      # Put first parameter into eax register

        test    $1, %eax        # Isloate least significant bit

        jnz     odd             # If it's not a zero, jump to odd

        imul    $3, %eax        # It's even, so multiply it by 3

        inc     %eax            # and add 4

        ret                     # and return it

even:

        shl    $2, %eax         # It's odd, so multiply by 4

        sub    $3, %eax         # and subtract 3

        ret                     # and return it

For the SPARC:

        .global f

f:

        andcc   %o0, 1, %g0

        bne     .L1

        sll     %o0, 2, %g2

        sll     %o0, 1, %g2

        add     %g2, %o0, %g2

        b       .L2

        add     %g2, 1, %o0

.L1:

        add     %g2, -3, %o0

.L2:

        retl

        nop

High-Level Languages

A high-level language gets away from all the constraints of a particular machine. HLLs have features such as:

• Names for almost everything: variables, types, subroutines, constants, modules
• Complex expressions (e.g. 2 * (y^5) >= 88 && sqrt(4.8) / 2 % 3 == 9)
• Control structures (conditionals, switches, loops)
• Composite types (arrays, structs)
• Type declarations
• Type checking
• Easy ways to manage global, local and heap storage
• Subroutines with their own private scope
• Abstract data types, modules, packages, classes
• Exceptions

The previous example looks like this in Fortran 77 (note how the code begins in column 7 or beyond):

       INTEGER FUNCTION F(N)

       INTEGER N

       IF (MOD(N, 2) .EQ. 0) THEN

           F = 3 * N + 1

       ELSE

           F = 4 * N - 3

       END IF

       RETURN

       END

and like this in Ada:

function F (N: Integer) return Integer is

begin

    if N mod 2 = 0 then

        return 3 * N + 1;

    else

        return 4 * N - 3;

    end if;

end F;

and like this in Fortran 90 (where the column requirements were finally removed):

integer function f (n)

    implicit none

    integer, intent(in) :: n

    if (mod(n, 2) == 0) then

        f = 3 * n + 1

    else

        f = 4 * n - 3

    end if

end function f

and like this in C and C++:

int f(const int n) {

    return (n % 2 == 0) ? 3 * n + 1 : 4 * n - 3;

}

and like this in Java and C#:

class ThingThatHoldsTheFunctionUsedInTheExampleOnThisPage {

    public static int f(int n) {

        return (n % 2 == 0) ? 3 * n + 1 : 4 * n - 3;

    }

}

and like this in Scala:

def f(n: Int) = if (n % 2 == 0) 3 * n + 1 else 4 * n - 3;

and like this in JavaScript:

function f(n) {

    return (n % 2 === 0) ? 3 * n + 1 : 4 * n - 3;

}

and like this in CoffeeScript:

f = (n) -> if n % 2 == 0 then 3 * n - 1 else 4 * n + 3

and like this in Smalltalk:

f

  ^self % 2 = 0 ifTrue:[3 * self + 1] ifFalse:[4 * self - 3]

and like this in ML:

fun f n = if n mod 2 = 0 then 3 * n + 1 else 4 * n - 3

and like this in Lisp and Scheme:

(defun f (n)

  (if (= (mod n 2) 0)

    (+ (* 3 n) 1)

    (- (* 4 n) 3)))

and like this in Clojure:

(defn f [n]

  (if (= (mod n 2) 0)

    (+ (* 3 n) 1)

    (- (* 4 n) 3)))

and like this in Prolog:

f(N, X) :- 0 is mod(N, 2), X is 3 * N + 1.

f(N, X) :- 1 is mod(N, 2), X is 4 * N - 3.

and like this in Perl:

sub f {

    my $n = shift;

    $n % 2 == 0 ? 3 * $n + 1 : 4 * $n - 3;

}

and like this in Python:

def f(n):

    return 3 * n + 1 if n % 2 == 0 else 4 * n - 3

and like this in Ruby:

def f(n)

  n % 2 == 0 ? 3 * n + 1 : 4 * n - 3;

end

and like this in Go:

func f(n int) int {

    if n % 2 == 0 {

        return 3 * n + 1

    } else {

        return 4 * n - 3

    }

}

and like this in Rust:

fn f(n: int) -> int {

    return if n % 2 == 0 {3 * n + 1} else {4 * n - 3}

}

and like this in Swift:

func f(n: Int) -> Int {

    return n % 2 == 0 ? 3 * n + 1 : 4 * n - 3

}