Navneet Kumar's Bookmarks tagged Closure → View Popular

You are here: Diigo Home > Navneet Kumar's Bookmarks

Ads by Google

Expand All 1 - 3 of 3

A JavaScript Module Pattern » Yahoo! User Interface Blog

Module Pattern closure private members

Tags: YUI, JavaScript, DesignPatterns, Advanced, Closure on 2008-06-16 and saved by15 people -All Annotations (0) -About

more fromyuiblog.com

21Expand

defmacro - Functional Programming For The Rest of Us

Tags: block, closure, continuity, erlang, functional, functional_language, language, programming on 2007-07-06 and saved by38 people -All Annotations (0) -About

more fromwww.defmacro.org

Alonzo Church developed a formal system called lambda calculus. The
system was essentially a programming language for one of these imaginary machines
John McCarthy (also a Princeton graduate) developed interest in Alonzo
Church's work. In 1958 he unveiled a List Processing language (Lisp)
Lisp machine - effectively a native hardware implementation of Alonzo's lambda calculus!
it was proved that lambda calculus is equivalent to a Turing machine.
It turns out that functional programs can keep state, except they don't use variables to do it. They use functions
instead. The state is kept in function parameters, on the stack. If you want to keep state for a while and every now
and then modify it, you write a recursive function
Ericsson designed a functional language called Erlang for use in its highly tolerant
and scalable telecommunication switches.
Erlang systems are not scalable and reliable. Java systems are. Erlang
systems are simply rock solid
Erlang engineers have been upgrading
live systems without stopping them for years.
Functions that operate on other functions (accept them
as arguments) are called higher order functions.
currying is used to reduce the number of arguments
only executes code when it's required
A lazy compiler thinks of functional code exactly as mathematicians
think of an algebra expression - it can cancel things out and completely prevent execution, rearrange pieces of code for higher efficiency,
even arrange code in a way that reduces errors, all guaranteeing optimizations won't break the code.
In a lazy language you have no guarantee that the first line will be executed before the second! This means we can't do IO, can't
use native functions in any meaningful way (because they need to be called in order since they depend on side effects), and can't
interact with the outside world! If we were to introduce
primitives that allow ordered code execution we'd lose the benefits of reasoning about our code mathematically
continuations, monads, and uniqueness typing.
continuations are a generalization of functions.
A "continuation" is a parameter we may choose to pass to our function that
specifies where the function should return.
Continuation
Passing Style or CPS
CPS version needs no stack! No function ever "returns" in the traditional sense, it just calls another
function with the result instead. We don't need to push function arguments on the stack with every call and then pop them back, we can
simply store them in some block of memory and use a jump instruction instead. We'll never need the original arguments - they'll never
be used again since no function ever returns!
What does the stack contain? Simply the arguments, and a
pointer to memory where the function should return. Do you see a light bulb? The stack simply contains continuation information! The
pointer to the return instruction in the stack is essentially the same thing as the function to call in CPS programs!
A continuation and a pointer to the return instruction in the stack are really the same thing, only a continuation
is passed explicitly, so that it doesn't need to be the same place where the function was called from
When we get a current continuation and store it somewhere, we end up
storing the current state of our program - freezing it in time. This is similar to an OS putting itself into hibernation. A continuation
object contains the information necessary to restart the program from the point where the continuation object was acquired.

http://okmij.org/ftp/Scheme/oop-in-fp.txt

Tags: closure, functional_programming, object-oriented, object-oriented-programming on 2006-09-16 -All Annotations (0) -About

more fromokmij.org

1 - 3 of 3

List 20 50 100

Notation: * = Private bookmark and comment|… = Clipping [?] | … = Public highlight [?]

Navneet Kumar's Related Tags

Selected tags

Closure

Related tags

See More Top Contributors

ema ame kay Bill Stocking roberto tazzoli Makoto Miura Jürgen R Plasser

Related Groups on Diigo

nuke.news

Members (2)

bookmarks (5664)
InfokeyDEV

Members (14)

bookmarks (314)
Authentic Learning

Members (101)

bookmarks (207)