:: wikimiki.org ::

Kid Programming Language

Kid programming language

Kid is a kernel programming language created by id Software. It is a refinement of P-TAC, used as an intermediate language at Id Software. Kid is based on the Lambda-calculus with first-class let-blocks and I-structures. It is made by Morrison Schwartz and has a 2005 copyright, but it freely distrubited as freeware. It is commonly used in basic computer classes for children.

References

- "A Syntactic Approach to Program Transformations", Z. Ariola et. al., SIGPLAN Notices 26(9):116-129 (Sept 1991). Category:Domain-specific programming languages

Programming language

A programming language or computer language is a standardized communication technique for expressing instructions to a computer. It is a set of syntactic and semantic rules used to define computer programs. A language enables a programmer to precisely specify (but see Genetic Programming) what data a computer will act upon, how these data will be stored/transmitted, and what actions will be taken under various circumstances.

Features of programming language

Each programming language can be thought of as a set of formal specifications concerning syntax, vocabulary, and meaning. These specifications usually include:
- Data Types
- Data Structures
- Instruction and Control Flow
- Design Philosophy
- Compilation and Interpretation Most languages that are widely used, or have been used for a considerable period of time, have standardization bodies that meet regularly to create and publish formal definitions of the language, and discuss extending or supplementing the already extant definitions.

Data types

Internally, all data in modern digital computers are stored simply as zeros or ones (binary). The data typically represent information in the real world such as names, bank accounts and measurements and so the low-level binary data are organized by programming languages into these high-level concepts. The particular system by which data are organized in a program is the type system of the programming language; the design and study of type systems is known as type theory. Languages can be classified as statically typed languages, and dynamically typed languages. Statically typed languages can be further subdivided into languages with manifest types, where each variable and function declaration has its type explicitly declared, and type-inferred languages. It is possible to perform type inference on programs written in a dynamically typed language, but it is entirely possible to write programs in these languages that make type inference infeasible. Sometimes dynamically typed languages are called latently typed. With statically typed languages, there usually are pre-defined types for individual pieces of data (such as numbers within a certain range, strings of letters, etc.), and programmatically named values (variables) can have only one fixed type, and allow only certain operations: numbers cannot change into names and vice versa. Most mainstream statically typed languages, such as C, C++, C#, Java and Delphi, require all types to be specified explicitly; advocates argue that this makes the program easier to understand, detractors object to the verbosity it produces. Type inference is a mechanism whereby the type specifications can often be omitted completely, if it is possible for the compiler to infer the types of values from the contexts in which they are used -- for example, if a variable is assigned the value 1, a type-inferring compiler does not need to be told explicitly that the variable is an integer. There are however many different uses for integers; it might e.g. make sense in a program to prevent inadvertent adding of a phone number to the number of apples in a box. Therefore some languages such as Ada allow defining different kinds of incompatible integers; this is called strong typing. Type-inferred languages can be more flexible to use, particularly when they also implement parametric polymorphism. Examples of type-inferring languages are Haskell, MUMPS and ML. Dynamically typed languages treat all data locations interchangeably, so inappropriate operations (like adding names, or sorting numbers alphabetically) will not cause errors until run-time -- although some implementations provide some form of static checking for obvious errors. Examples of these languages are APL, Objective-C, Lisp, Smalltalk, JavaScript, Tcl, Prolog, Python, and Ruby. Strongly typed languages do not permit the usage of values as different types; they are rigorous about detecting incorrect type usage, either at runtime for dynamically typed languages, or at compile time for statically typed languages. Ada, Java, ML, and Oberon are examples of strongly typed languages. Weakly typed languages do not strictly enforce type rules or have an explicit type-violation mechanism, often allowing for undefined behavior, segmentation violations, or other unsafe behavior if types are assigned incorrectly. C, assembly language, C++, and Tcl are examples of weakly typed languages. Note that strong vs. weak is a continuum; Java is a strongly typed language relative to C, but is weakly typed relative to ML. Use of these terms is often a matter of perspective, much in the way that an assembly language programmer would consider C to be a high-level language while a Java programmer would consider C to be a low-level language. Note that strong and static are orthogonal concepts. Java is a strongly, statically typed language. C is a weakly, statically typed language. Python is a strongly, dynamically typed language. Tcl is a weakly, dynamically typed language. But beware that some people incorrectly use the term strongly typed to mean strongly, statically typed, or, even more confusingly, to mean simply statically typed--in the latter usage, C would be called strongly typed, despite the fact that C doesn't catch that many type errors and that it's both trivial and common to defeat its type system (even accidentally). Aside from when and how the correspondence between expressions and types is determined, there's also the crucial question of what types the language defines at all, and what types it allows as the values of expressions (expressed values) and as named values (denoted values). Low-level languages like C typically allow programs to name memory locations, regions of memory, and compile-time constants, while allowing expressions to return values that fit into machine registers; ANSI C extended this by allowing expressions to return struct values as well (see record). Functional languages often restrict names to denoting run-time computed values directly, instead of naming memory locations where values may be stored, and in some cases refuse to allow the value denoted by a name to be modified at all. Languages that use garbage collection are free to allow arbitrarily complex data structures as both expressed and denoted values. Finally, in some languages, procedures are allowed only as denoted values (they cannot be returned by expressions or bound to new names); in others, they can be passed as parameters to routines, but cannot otherwise be bound to new names; in others, they are as freely usable as any expressed value, but new ones cannot be created at run-time; and in still others, they are first-class values that can be created at run-time.

Data structures

Most languages also provide ways to assemble complex data structures from built-in types and to associate names with these new combined types (using arrays, lists, stacks, files). Object oriented languages allow the programmer to define data-types called "Objects" which have their own intrinsic functions and variables (called methods and attributes respectively). A program containing objects allows the objects to operate as independent but interacting sub-programs: this interaction can be designed at coding time to model or simulate real-life interacting objects. This is a very useful, and intuitive, functionality. Languages such as Python and Ruby have developed as OO (Object oriented) languages. They are comparatively easy to learn and to use, and are gaining popularity in professional programming circles, as well as being accessible to non-professionals. It is commonly thought that object-orientation makes languages more intuitive, increasing the public availability and power of customized computer applications.

Instruction and control flow

Once data has been specified, the machine must be instructed how to perform operations on the data. Elementary statements may be specified using keywords or may be indicated using some well-defined grammatical structure. Each language takes units of these well-behaved statements and combines them using some ordering system. Depending on the language, differing methods of grouping these elementary statements exist. This allows one to write programs that are able to cover a variety of input, instead of being limited to a small number of cases. Furthermore, beyond the data manipulation instructions, other typical instructions in a language are those used for control flow (branches, definitions by cases, loops, backtracking, functional composition).

Design philosophy

For the above-mentioned purposes, each language has been developed using a special design or philosophy. Some aspect or another is particularly stressed by the way the language uses data structures, or by which its special notation encourages certain ways of solving problems or expressing their structure. Since programming languages are artificial languages, they require a high degree of discipline to accurately specify which operations are desired. Programming languages are not error tolerant; however, the burden of recognizing and using the special vocabulary is reduced by help messages generated by the programming language implementation. There are a few languages which offer a high degree of freedom in allowing self-modification in which a program re-writes parts of itself to handle new cases. Typically, only machine language, Prolog, PostScript, and the members of the Lisp family (Common Lisp, Scheme) provide this capability. In MUMPS language this technique is called dynamic recompilation; emulators and other virtual machines exploit this technique for greater performance.

Compilation and interpretation

There are, broadly, two approaches to execute a program written in a given language. These approaches are known as compilation, done by a program known as a compiler; and interpretation, done by an interpreter. Some programming language implementations support both interpretation and compilation. An interpreter parses a computer program and executes it directly. One can imagine this as following the instructions of the program line-by-line. In contrast, a compiler translates the program into machine code -- the native instructions understood by the computer's processor. The compiled program can then be run by itself. Compiled programs usually run faster than interpreted ones, because the overhead of understanding and translating the programming language syntax has already been done. However, interpreters are frequently easier to write than compilers, and can more easily support interactive debugging of a program.

History of programming languages

The development of programming languages, unsurprisingly, follows closely the development of the physical and electronic processes used in today's computers. Programming languages have been under development for years and will remain so for many years to come. They got their start with a list of steps to wire a computer to perform a task. These steps eventually found their way into software and began to acquire newer and better features. The first major languages were characterized by the simple fact that they were intended for one purpose and one purpose only, while the languages of today are differentiated by the way they are programmed in, as they can be used for almost any purpose. And perhaps the languages of tomorrow will be more natural with the invention of quantum and biological computers. Charles Babbage is often credited with designing the first computer-like machines, which had several programs written for them (in the equivalent of assembly language) by Ada Lovelace. In the 1940s the first recognizably modern, electrically powered computers were created. Some military calculation needs were a driving force in early computer development, such as encryption, decryption, trajectory calculation and massive number crunching needed in the development of atomic bombs. At that time, computers were extremely large, slow and expensive: advances in electronic technology in the post-war years led to the construction of more practical electronic computers. At that time only Konrad Zuse imagined the use of a programming language (developed eventually as Plankalkül) like those of today for solving problems. Subsequent breakthroughs in electronic technology (transistors, integrated circuits, and chips) drove the development of increasingly reliable and more usable computers. The first widely used high level programming language was Fortran, developed during 1954–57 by an IBM team led by John W. Backus. It is still widely used for numerical work, with the latest international standard released in 2004. A [http://www.levenez.com/lang/history.html Computer Languages History] graphic shows a timeline from Fortran in 1954. Dennis Ritchie and Brian Kernighan developed the C programming language, initially for DEC PDP-11 in 1970. Later with lead of Bjarne Stroustrup the programming language C++ appeared in 1985 as an Object oriented language vertically compatible with C. Sun Microsystems released Java in 1995 which became very popular as an introductory programming language taught in universities. Microsoft presented the C# programming language in 2001 which is very similar to C++ and Java. There are many, many other languages (cf. List of programming languages).

Classifications of programming languages

- Array
- Aspect-oriented
- Assembly
- Concatenative
- Concurrent
- Curly-bracket
- Data-structured
- Dataflow
- Declarative
- Domain-specific
- Dynamic
- Educational
- Esoteric
- Functional
- General-purpose
- Imperative
- Interface description
- Logic
- Multiparadigm
- Object-oriented
- Prototype-based
- Pattern directed invocation
- Procedural
- Quantum
- Reflective
- Scripting
- Synchronous
- Visual
- Lists of all programming languages
- Alphabetical
- Categorical
- Chronological
- Generational

Formal semantics

The rigorous definition of the meaning of programming languages is the subject of formal semantics.

External links

- [http://merd.sourceforge.net/pixel/language-study/syntax-across-languages/ Syntax Patterns for Various Languages]
- Wikisource Source Code Examples
- [http://www.99-bottles-of-beer.net/ 99 Bottles of Beer] - One program written in 813 different programming languages
- [http://dmoz.org/Computers/Programming/Languages/ Open Directory - Computer Programming Languages]
- [http://ixpubs.com/ixg/comp_lang_quik_ref.html Computer Languages Quick Reference Chart]
- [http://www.levenez.com/lang/history.html Computer Languages History graphical chart]
- [http://ixpubs.com/ixg/comp_lang_ref.html Instant Expert - Computer Language Reference]
- [http://cgibin.erols.com/ziring/cgi-bin/cep/cep.pl Dictionary of Programming Languages]
- [http://www.techbookreport.com/ProgIndex.html TechBookReport - Programming] - Book and software reviews on all aspects of programming and programming languages.
- [http://www.computer-books.us/ Computer-Books.us] - A collection of programming books available for free download.
- [http://people.ku.edu/~nkinners/LangList/Extras/langlist.htm The Language List] - A catalog of claimed about 2 500 language entries
- Category:Computer languages ja:プログラミング言語 th:ภาษาโปรแกรม

Lambda calculus

In computer science, the lambda calculus is a formal system designed to investigate function definition, function application, and recursion. It was introduced by Alonzo Church and Stephen Cole Kleene in the 1930s; Church used the lambda calculus in 1936 to give a negative answer to the Entscheidungsproblem. The calculus can be used to cleanly define what a computable function is. The question of whether two lambda calculus expressions are equivalent cannot be solved by a general algorithm, and this was the first question, even before the halting problem, for which undecidability could be proved. Lambda calculus has greatly influenced functional programming languages, especially Lisp. The lambda calculus can be called the smallest universal programming language. The lambda calculus consists of a single transformation rule (variable substitution) and a single function definition scheme. The lambda calculus is universal in the sense that any computable function can be expressed and evaluated using this formalism. It is thus equivalent to Turing machines. However, the lambda calculus emphasizes the use of transformation rules, and does not care about the actual machine implementing them. It is an approach more related to software than to hardware. This article deals with the "untyped lambda calculus" as originally conceived by Church. Since then, some typed lambda calculi have been developed.

History

Originally, Church had tried to construct a complete formal system for the foundations of mathematics; when the system turned out to be susceptible to the analog of Russell's paradox, he separated out the lambda calculus and used it to study computability, culminating in his negative answer to the Entscheidungsproblem.

Informal description

In lambda calculus, every expression stands for a function with a single argument; the argument of the function is in turn a function with a single argument, and the value of the function is another function with a single argument. A function is anonymously defined by a lambda expression which expresses the function's action on its argument. For instance, the "add-two" function f such that f(x) = x + 2 would be expressed in lambda calculus as λ x. x + 2 (or equivalently as λ y. y + 2; the name of the formal argument is immaterial) and the number f(3) would be written as (λ x. x + 2) 3. Function application is left associative: f x y = (f x) y. Consider the function which takes a function as argument and applies it to the argument 3: λ x. x 3. This latter function could be applied to our earlier "add-two" function as follows: (λ x. x 3) (λ x. x+2). It is clear that the three expressions : (λ x. x 3) (λ x. x+2) and (λ x. x + 2) 3 and 3 + 2 are equivalent. A function of two variables is expressed in lambda calculus as a function of one argument which returns a function of one argument (see currying). For instance, the function f(x, y) = x - y would be written as λ x. λ y. x - y. A common convention is to abbreviate curried functions as, for instance, λ x y. x - y. The three expressions : (λ x y. x - y) 7 2 and (λ y. 7 - y) 2 and 7 - 2 are equivalent. It is this equivalence of lambda expressions which in general can not be decided by an algorithm. Not every lambda expression can be reduced to a definite value like the ones above; consider for instance : (λ x. x x) (λ x. x x) or : (λ x. x x x) (λ x. x x x) and try to visualize what happens as you start to apply the first function to its argument. (λ x. x x) is also known as the ω combinator; ((λ x. x x) (λ x. x x)) is known as Ω, ((λ x. x x x) (λ x. x x x)) as Ω₂, etc. While the lambda calculus itself does not contain symbols for integers or addition, these can be defined as abbreviations within the calculus and arithmetic can be expressed as we will see below. Lambda calculus expressions may contain free variables, i.e. variables not bound by any λ. For example, the variable y is free in the expression (λ x. y) , representing a function which always produces the result y . Occasionally, this necessitates the renaming of formal arguments, for instance in order to reduce :(λ x y. y x) (λ x. y) to λ z. z (λ x. y) If one only formalizes the notion of function application and does not allow lambda expressions, one obtains combinatory logic.

Formal definition

Formally, we start with a countably infinite set of identifiers, say . The set of all lambda expressions can then be described by the following context-free grammar in BNF: #<expr> ::= <identifier> #<expr> ::= (λ <identifier>. <expr>) #<expr> ::= (<expr> <expr>) The first two rules generate functions, while the third describes the application of a function to an argument. Usually the parentheses for lambda abstraction (rule 2) and function application (rule 3) are omitted if there is no ambiguity under the assumptions that (1) function application is left-associative, and (2) a lambda binds to the entire expression following it. For example, the expression ((λ x. (x x)) (λ y. y)) can be simply written as (λ x. x x) λ y. y. Lambda expressions such as λ x. (x y) do not define functions because the occurrence of the variable y is free, i.e., it is not bound by any λ in the expression. The binding of occurrences of variables is (with induction upon the structure of the lambda expression) defined by the following rules: # In an expression of the form V, where V is a variable, this V is the single free occurrence. # In an expression of the form λ V. E, the free occurrences are the free occurrences in E except those of V. In this case the occurrences of V in E are said to be bound by the λ before V. # In an expression of the form (E E′), the free occurrences are the free occurrences in E and E′. Over the set of lambda expressions an equivalence relation (here denoted as ) is defined that captures the intuition that two expressions denote the same function. This equivalence relation is defined by the so-called alpha-conversion rule and the beta-reduction rule. α-conversion The alpha-conversion rule is intended to express the idea that the names of the bound variables are unimportant; for example that λx.x and λy.y are the same function. However, the rule is not as simple as it first appears. There are a number of restrictions on when one bound variable may be replaced with another. The alpha-conversion rule states that if V and W are variables, E is a lambda expression, and E[V := W] means the expression E with every free occurrence of V in E replaced with W, then : λ V. E λ W. E[V := W] if W does not appear freely in E and W is not bound by a λ in E whenever it replaces a V. This rule tells us for example that λ x. (λ x. x) x is the same as λ y. (λ x. x) y. β-reduction The beta-reduction rule expresses the idea of function application. It states that : ((λ V. E) E′)E[V := E′] if all free occurrences in E′ remain free in E[V := E′]. The relation is then defined as the smallest equivalence relation that satisfies these two rules. A more operational definition of the equivalence relation can be given by applying the rules only from left to right. A lambda expression which does not allow any beta reduction, i.e., has no subexpression of the form ((λ V. E) E′), is called a normal form. Not every lambda expression is equivalent to a normal form, but if it is, then the normal form is unique up to naming of the formal arguments. Furthermore, there is an algorithm for computing normal forms: keep replacing the first (left-most) formal argument with its corresponding concrete argument, until no further reduction is possible. This algorithm halts if and only if the lambda expression has a normal form. The Church-Rosser theorem then states that two expressions result in the same normal form up to renaming of the formal arguments if and only if they are equivalent. η-conversion There is a third rule, eta-conversion, which may be added to these two to form a new equivalence relation. Eta-conversion expresses the idea of extensionality, which in this context is that two functions are the same iff they give the same result for all arguments. Eta-conversion converts between λ x. f x and f whenever x does not appear free in f. This can be seen to be equivalent to extensionality as follows: If f and g are extensionally equivalent, i.e. if f ag a for all lambda expressions a, then in particular by taking a to be a variable x not appearing free in f nor g we have f x g x and hence λ x. f x λ x. g x, and so by eta-conversion f g. So if we take eta-conversion to be valid, we find extensionality is valid. Conversely if extensionality is taken to be valid, then since by beta-reduction for all y we have (λ x. f x) y f y, we have λ x. f x f; i.e., eta-conversion is found to be valid. Arithmetic in lambda calculus There are several possible ways to define the natural numbers in lambda calculus, but by far the most common are the Church numerals, which can be defined as follows: : 0 := λ f x. x : 1 := λ f x. f x : 2 := λ f x. f (f x) : 3 := λ f x. f (f (f x)) and so on. Intuitively, the number n in lambda calculus is a function that takes a function f as argument and returns the n-th power of f. That is to say, a Church numeral is a higher-order function -- it takes a single-argument function f, and returns another single-argument function. (Note that in Church's original lambda calculus, the formal parameter of a lambda expression was required to occur at least once in the function body, which made the above definition of 0 impossible.) Given this definition of the Church numerals, we can define a successor function, which takes a number n and returns n + 1: : SUCC := λ n f x. f (n f x) Addition is defined as follows: : PLUS := λ m n f x. m f (n f x) PLUS can be thought of as a function taking two natural numbers as arguments and returning a natural number; it is fun to verify that : PLUS 2 3 and 5 are equivalent lambda expressions. Multiplication can then be defined as : MULT := λ m n. m (PLUS n) 0, the idea being that multiplying m and n is the same as m times adding n to zero. Alternatively : MULT = λ m n f. m (n f) The predecessor PRED n = n - 1 of a positive integer n is more difficult: : PRED := λ n f x. n (λ g h. h (g f)) (λ u. x) (λ u. u) or alternatively : PRED = λ n. n (λ g k. (g 1) (λ u. PLUS (g k) 1) k) (λ v. 0) 0 Note the trick (g 1) (λ u. PLUS (g k) 1) k which evaluates to k if g(1) is zero and to g(k) + 1 otherwise. Logic and predicates By convention, the following two definitions (known as Church booleans) are used for the boolean values TRUE and FALSE: : TRUE := λ x y. x : FALSE := λ x y. y ::(Note that FALSE is equivalent to the Church numeral zero defined above) Then, with these two λ-terms, we can define some logic operators: : AND := λ p q. p q FALSE : OR := λ p q. p TRUE q : NOT := λ p. p FALSE TRUE : IFTHENELSE := λ p x y. p x y We are now able to compute some logic functions, as for example: : AND TRUE FALSE ::≡ (λ p q. p q FALSE) TRUE FALSE →_β TRUE FALSE FALSE ::≡ (λ x y. x) FALSE FALSE →_β FALSE and we see that AND TRUE FALSE is equivalent to FALSE. A predicate is a function which returns a boolean value. The most fundamental predicate is ISZERO which returns TRUE if and only if its argument is the Church numeral 0: : ISZERO := λ n. n (λ x. FALSE) TRUE The availability of predicates and the above definition of TRUE and FALSE make it convenient to write "if-then-else" statements in lambda calculus. Recursion Recursion is the definition of a function using the function itself; on the face of it, lambda calculus does not allow this. However, this impression is misleading. Consider for instance the factorial function f(n) recursively defined by :f(n) = 1, if n = 0; and n·f(n-1), if n>0. In lambda calculus, one cannot define a function which includes itself. To get around this, one may start by defining a function, here called g, which takes a function f as an argument and returns another function that takes n as an argument: :g := λ f n. (1, if n = 0; and n·f(n-1), if n>0). The function that g returns either returns the constant 1, or returns n times the application of the function f to n-1. Using the ISZERO predicate, and boolean and algebraic definitions described above, the function g can be defined in lambda calculus. However, g by itself is still not recursive; in order to use g to create the recursive factorial function, the function passed to g as f must have specific properties. Namely, the function passed as f must expand to the function g called with one argument -- and that argument must be the function that was passed as f again! In other words, f must expand to g(f). This call to g will then expand to the above factorial function and calculate down to another level of recursion. In that expansion the function f will appear again, and will again expand to g(f) and continue the recursion. This kind of function, where f = g(f), is called a fixed-point of g, and it turns out that it can be implemented in the lambda calculus using what is known as the paradoxical operator or fixed-point operator and is represented as Y -- the Y combinator: :Y = λ g. (λ x. g (x x)) (λ x. g (x x)) In the lambda calculus, Y g is a fixed-point of g, as it expands to g (Y g). Now, to complete our recursive call to the factorial function, we would simply call g (Y g) n, where n is the number we are calculating the factorial of. Given n = 5, for example, this expands to: :(λ n.(1, if n = 0; and n·((Y g)(n-1)), if n>0)) 5 :1, if 5 = 0; and 5·(g(Y g)(5-1)), if 5>0 :5·(g(Y g) 4) :5·(λ n. (1, if n = 0; and n·((Y g)(n-1)), if n>0) 4) :5·(1, if 4 = 0; and 4·(g(Y g)(4-1)), if 4>0) :5·(4·(g(Y g) 3)) :5·(4·(λ n. (1, if n = 0; and n·((Y g)(n-1)), if n>0) 3)) :5·(4·(1, if 3 = 0; and 3·(g(Y g)(3-1)), if 3>0)) :5·(4·(3·(g(Y g) 2))) : ... And so on, evaluating the structure of the algorithm recursively. Every recursively defined function can be seen as a fixed point of some other suitable function, and therefore, using Y, every recursively defined function can be expressed as a lambda expression. In particular, we can now cleanly define the subtraction, multiplication and comparison predicate of natural numbers recursively. Computable functions and lambda calculus A function F: N → N of natural numbers is a computable function if and only if there exists a lambda expression f such that for every pair of x, y in N, F(x) = y if and only if f x y, where x and y are the Church numerals corresponding to x and y, respectively. This is one of the many ways to define computability; see the Church-Turing thesis for a discussion of other approaches and their equivalence. Undecidability of equivalence There is no algorithm which takes as input two lambda expressions and outputs TRUE or FALSE depending on whether or not the two expressions are equivalent. This was historically the first problem for which the unsolvability could be proven. Of course, in order to do so, the notion of algorithm has to be cleanly defined; Church used a definition via recursive functions, which is now known to be equivalent to all other reasonable definitions of the notion. Church's proof first reduces the problem to determining whether a given lambda expression has a normal form. A normal form is an equivalent expression which cannot be reduced any further. Then he assumes that this predicate is computable, and can hence be expressed in lambda calculus. Building on earlier work by Kleene and constructing a Gödel numbering for lambda expressions, he constructs a lambda expression e which closely follows the proof of Gödel's first incompleteness theorem. If e is applied to its own Gödel number, a contradiction results. Lambda calculus and programming languages Most programming languages are equivalent to the lambda calculus extended with some additional programming language constructs. The classical work where this viewpoint was put forward was Peter Landin's "A Correspondence between ALGOL 60 and Church's Lambda-notation", published in CACM in 1965. The key point is that the lambda calculus expresses the kind of procedural abstraction and application useful for any programming language. Prominently, functional programming languages are basically the lambda calculus with some constants and datatypes added. Lisp uses a variant of lambda notation for defining functions, but only its purely functional subset is really equivalent to lambda calculus. Strictly speaking, this holds only for modern dialects of Lisp, such as Common Lisp and Scheme. More archaic Lisps, such as Emacs Lisp, still use dynamic binding, and so are not based on the lambda calculus. Rather, they are based on the syntax of the lambda calculus, together with a misunderstanding of the notion of binding and substitution in the lambda calculus. In Lisp terminology, this is known as the Funarg problem. The lambda calculus is thus a fundamental theory in theoretical computer science and in programming language theory. Theory of the lambda calculus says that lambda calculus computations can always be carried out sequentially not that they must be carried out sequentially. The lambda calculus is suitable for expressing some kinds of parallelism, e.g., the parallel evaluation of the arguments of a procedure. However the lambda calculus does not in general implement concurrency, e.g., a shared financial account that is updated concurrently. On the other hand concurrent computation as in the Actor model and Process calculi can perform the parallelism of the lambda calculus. The difference between parallelism in the lambda calculus and concurrency in Actors is reflected in that the Actor model has unbounded nondeterminism whereas the nondeterministic lambda calculus has bounded nondeterminism. See also - SKI combinator calculus - H.P. Barendregt's Lambda cube - Jean-Yves Girard's System F - Thierry Coquand's calculus of constructions - Typed lambda calculus - Curry-Howard isomorphism - Anonymous recursion - Unlambda References - Abelson, Harold & Gerald Jay Sussman. Structure and Interpretation of Computer Programs. The MIT Press. ISBN 0262510871. - Barendregt, Henk, [http://www.elsevier.com/wps/find/bookdescription.cws_home/501727/description#description The lambda calculus, its syntax and semantics], North-Holland (1984), is the comprehensive reference on the (untyped) lambda calculus; see also the paper [http://citeseer.ist.psu.edu/barendregt94introduction.html Introduction to Lambda Calculus]. - Church, Alonzo, An unsolvable problem of elementary number theory, American Journal of Mathematics, 58 (1936), pp. 345–363. This paper contains the proof that the equivalence of lambda expressions is in general not decidable. - Punit,Gupta, Amit & Ashutosh Agte, Untyped lambda-calculus, alpha-, beta- and eta- reductions and recursion - Henz, Martin, The Lambda Calculus. Formally correct development of the Lambda calculus. - Kleene, Stephen, A theory of positive integers in formal logic, American Journal of Mathematics, 57 (1935), pp. 153–173 and 219–244. Contains the lambda calculus definitions of several familiar functions. - Larson, Jim, [http://www.jetcafe.org/~jim/lambda.html An Introduction to Lambda Calculus and Scheme]. A gentle introduction for programmers. Some parts of this article are based on material from FOLDOC, used with permission. External links - L. Allison, [http://www.csse.monash.edu.au/~lloyd/tildeFP/Lambda/Examples/ Some executable λ-calculus examples] - Georg P. Loczewski, [http://www.lambda-bound.com/book/lambdacalc/lcalconl.html The Lambda Calculus and A++] - Raùl Rojas, [http://www.inf.fu-berlin.de/lehre/WS03/alpi/lambda.pdf A Tutorial Introduction to the Lambda Calculus] (PDF) - David C. Keenan, [http://users.bigpond.net.au/d.keenan/Lambda/ To Dissect a Mockingbird: A Graphical Notation for the Lambda Calculus with Animated Reduction] Category:Mathematical logic Category:Computational models Category:Logic in computer science Category:Lambda calculus Category:Theoretical computer science Category:Formal methods ja:ラムダ計算 LeT Lashkar-e-Toiba or Lashkar-i-Taiba (the Army of the Pure) is a Kashmir separatist group that uses terrorist strategies. It was formed in the year 1990 and is based in Muridke, Pakistan and Muzaffarabad, Pakistan-administered Kashmir. The group is active in carrying out attacks on Indian armed forces and civilians in Kashmir. It is considered a well-trained armed wing of Pakistan-based Markaz Dawa-Wal-Irshad (the Centre for Religious Learning and Propagation), an organisation with Islamist views. US Secretary of State Colin Powell in a notification on December 26, 2001 designated Lashkar-e-Toiba as a foreign terrorist organisation. Ideology Lashkar's professed ideology goes beyond challenging Indian rule in Jammu and Kashmir. In a pamphlet entitled Why Are We Waging Jihad? the group defined its agenda as the restoration of Islamic rule over all parts of India.. It seems that in their view, the restoration of Secularism in India after the collapse of the Islamic rule of the Islamic Mughal Emperor of Aurangzeb was a historic wrong they seek to set right. Lashkar-e-Toiba is believed responsible for the series of attacks on August 1-2,2000, in which more than 100 people, most of who were civilians, were killed. Organisation and methods Lashkar-e-Toiba has an estimated strength of 300 and is believed to be headed by Mohammed Latif. It operates mostly in the Kashmir Valley which includes the districts of Baramulla, Anatnag, Ponch and Srinagar. Lashkar-e-Toiba has carried out several suicide bombing attacks on Indian soldiers and civilians. The first suicide attacks was targeted at a residential complex of the Indian Border Security Force in Bandipore near Srinagar. The attack on the headquarters of the Special Operations Group (SOG) on December 27, 1999 was by far the most prominent suicide attack on Indian troops. After being banned by both USA and Pakistan the Lashkar-e-Toiba divided into various splinter groups that operate under different names such as Jamaat Ud Dawa Pakistan,Al Madina and Al Mansurian. It is thought that hundreds of Lashkar-e-Toiba men died when their base and training buildings collapsed in the 2005 Kashmir earthquake. However, they have been accused of involvement in or even the organisation of the terrorist attack in Delhi on October 29, 2005. Role in India-Pakistan relations India accuses Lashkar-e-Toiba of practising ethnic cleansing directed against Hindu residents of Kashmir, particularly in the Jammu region. On March 20, 2000, for example, the militant group killed 35 Sikh and Hindu civilians at Chattisinghpora, among other similar incidents. Pakistan denies responsibility for Lashkar-e-Toiba's activities, but India alleges evidence relating to its non-military wing's fund raising activities in Pakistan indicates otherwise. Recent peace efforts by the Musharraf administration have led to a crackdown of its operations in Kashmir, compelling it to change name to Tehrik-e-Furqan. India accuses Lashkar of involvement in the December 13, 2001 attack on the Parliament of India in New Delhi. On January 16 2004, Randall Todd Royer, age 30, of Falls Church, Virginia, pleaded guilty to federal weapons and explosives charges in U.S. District Court in Alexandria, Virginia. Royer is one of 11 men originally charged in the case. Another is Ibrahim Ahmed al-Hamdi, age 26, of Alexandria, Virginia. Both were said to be members of Lashkar-e-Toiba and were part of a group of men who played paintball in the Virginia countryside to prepare for training that could have targeted the United States, according to government prosecutors. As of November 2005, Lashkar-e-Toiba is suspected of involvement in the Delhi bombings. Indian Prime Minister Manmohan Singh announced that he expected Pakistan to honour its commitment to fighting terrorism [http://news.bbc.co.uk/1/hi/world/south_asia/4393532.stm] following suspicions by Indian intelligence services of a foreign link to the attacks. In 2005, Lashkar-e-Toiba was "banned" by the United Nations for suspected links with Al Qaida. See also - Terrorism in Kashmir - Hizbul Mujahideen - Terrorism in Pakistan External links - [http://www.ict.org.il/inter_ter/orgdet.cfm?orgid=81 Institute for Conflict Management's page on Lashkar-e-Toiba] - [http://www.satp.org/satporgtp/countries/india/states/jandk/terrorist_outfits/lashkar_e_toiba.htm South Asia Terrorism Portal's page on Lashkar-e-Toiba] - [http://www.webster-dictionary.org/definition/Lashkar-e-Toiba Lashkar-e-Toiba dictionary definition] from Webster's Online Dictionary - [http://news.bbc.co.uk/1/hi/world/south_asia/3181925.stm Profile of Laskar-e-Toiba] on BBC - [http://www.cdi.org/terrorism/lt.cfm Center for Defense Information article] - [http://news.bbc.co.uk/2/hi/south_asia/3181925.stm BBC] Profile: Lashkar-e-Toiba - [http://library.nps.navy.mil/home/tgp/lt.htm US Navy Terror Group Profiles] - [http://www.satp.org/satporgtp/countries/india/states/jandk/terrorist_outfits/lashkar_e_toiba_lt.htm Incidents involving LeT] Category:Islamist groups Category:Jihadist organizations Category:Terrorism in India Category:Kashmir Fjends Fjends é um município da Dinamarca, localizado na região noroeste, no condado de Viborg. O município tem uma área de 236,19 km² e uma população de 8 136 habitantes, segundo o censo de 2004. - [http://www.fjends.dk/ Site oficial] Categoria:Municípios da Dinamarca zujer hotels edinburgh uk Calling Cards Casino nauka

:: RELATED NEWS ::

Horten Ho XVIII
The Horten Ho XVIII was a proposed intercontinental bomber that would have been based upon the Horten Ho 229 design. Like the Ho 229, it would have retained the stealth capabilities of the previous design, as well as a large fuel capacity, which would allow it to fly across the Atlantic Ocean both ways without refueling.

External links

- [http://www.luft46.com/horten/horten.html Luft'46]
- [http://www.nurflugel.com/

Len Castle
Len Castle is a New Zealand Potter. Born in Auckland in 1924, he graduated with a Bachelor of Science in 1946 form University of Auckland and trained as a secondary schoolteacher, eventually taking a lecturing position at the Auckland College of Education. Self taught, he began making his first pottery in 1947. In 1956 he moved to

Tiloukaikt
Tiloukaikt (also Tilokaikt or Teelonkike) (unknown - 1849) was a Native American leader of the Cayuse tribe in the northwestern United States. He was involved in the Whitman Massacre and was a primary leader during the subsequent Cayuse War. The Cayuse,

Chief of the Land Staff
The Chief of the Land Staff is the head of the Canadian Forces Land Force Command, the Canadian army. It has been such since the Mobile Command was renamed the Land Force Command in the 1990s. Prior to this, the position was held by the Commander, Mobile Command.

Chiefs of the Land Staff, To present

- General Rick Hillier 2003-2005
- Dragon Magazine. Its sister comic, Mount Zogon is published in Dungeon Magazine. The comic follows the exploits of a trio of adventures, collectively called Domato's Delvers. The members are:
- Domato- human fighter and the leader of the Delvers. Carries a magical item called an Orb of Life.
- Dindil- dwarven fighter, tends to die a lot. This is very annoying for Domato

North olmsted high school
North Olmsted City Schools is the public school district that serves the city of North Olmsted, Ohio. As of 2005, 4,573 students attended its nine schools.

Schools

- North Olmsted High School, grades 8-12. Enrollment is approximately 1,600.
- North Olmsted Middle School, grades 7-8.
- Chestnut Intermediate School, grades 4-7.
- Maple Intermediate School, grades 4-6.
- Pine Intermediate School, grades PK-6.
- Birch Primary School, grade

Nabiel Makarim
Nabiel Makarim was the Minister of the Environment for Indonesia. He graduated from Harvard University and received his Master's degree in Management from the Sloan Fellows program of the MIT Sloan School of Management. Makarim Makarim, Na

Huang Mei Gui tea
Huang Mei Gui Oolong tea is a very new Wuyi Oolong tea, developed about 3 years ago. It has a highly aromatic fragrance and a lighter floral taste than most other Wuyi Oolongs. The colour of the steeped leaves is a very light green, much greener than other Wuyi teas.

References

- [http://www.jingteashop.com/pd_huang_mei.cfm Huang Mei Gui at