A memória possui 3 segmentos: text/code segment, stack segment e heap segment.
-
Text/code segment: onde o código compilado do programa reside. É a representação do programa em linguagem de máquina com as operações que devem ser realizadas, incluindo todas as funções, tanto as definidas pelo usuário, como as do sistema.
-
Stack segment: espaço onde variáveis automáticas que estão dentro de funções serão alocadas. Usa o conceito de FIFO (first in, first out), ou seja, dados são alocados e desalocados por apenas uma das "pontas", o Top do stack. Ex: todas as variáveis declaradas no main() entram no stack. Se main() chamar func1(), func1() - junto com parâmetros que tiver - passa para o Top do stack. Quando func1() retornar algum valor (return), ela é desalocada do stack. Evidente que ficará lixo nessa área da memória, deixado por um prévio uso.
-
Heap segment: é um espaço mais estável de armazenamento de dados na memória; memória alocada no heap ficará lá enquanto o programa durar. Sendo assim, variáveis globais e estáticas (static) são alocadas no heap. Caso a memória alocada no heap seja 0 quando o programa começa, será 0 até que o programa faça uso dela. Este segmento não precisa conter lixo.
Fonte: http://www-ee.eng.hawaii.edu/~tep/EE150/book/chap14/subsection2.1.1.8.html
No caso do C, via de regra quando damos malloc(), a memória é armazenada no heap. É boa prática ter ponteiros no segmento stack, que apontam para endereços que estão no segmento heap. Tais endereços aí sim conterão os valores desejados.
Exemplo disso em C:
int * x[10]; //vetor de ponteiros que apontam para endereços que contém inteiros - estão no stack
int i; //inicializa variável inteira - está no stack
for(i = 0; i < 10; ++i) //stack
x[i] = malloc(sizeof(int)*10); //os endereços gerados pelo malloc estão todos no heap!
No caso neste código eu tenho 10 ponteiros apontando para 10 vetores de 10 posições. O endereço para estes vetores estão na stack e os valores, alocação, data, está na heap.
Em LISP um lambda é apenas uma função anônima. Em Python, um lambda é uma função anônima especificadamente limitada a apenas uma expressão.
Em JS é comumente utilizado quando se usa uma função anônima para ser passada como parâmetro na chamada de outra função (o que, levando à risca o conceito de Callback, é um Callback).
Lexical Scope e Closure são praticamente sinônimos. Praticamente por que "Dynamic Scope" também é um tipo de Closure, mas onde o contexto que consegue ter acesso à variáveis, é a chamada de uma função. Ex (C-like syntax) de Dynamic Scope:
void fun()
{
printf("%d", x);
}
void dummy1()
{
int x = 5;
fun();
}
Em suma: Closure é o nome que se dá ao comportamento de um método ou função carregar o escopo onde ela foi criada. Essa função/método, carrega consigo valores do mundo (escopo) de onde foi criada, e pode sair passando tais valores nos outros contextos onde for chamada.
Em Javascript:
function newCounter () {
var i = 0
return function () {
i = i + 1;
return i;
}
}
c1 = newCounter()
alert(c1());
alert(c1());
alert(c1());
alert(c1());
alert(c1());
Em Ruby:
def new_counter
i = 0
lambda { i = i + 1 }
end
c1 = new_counter
puts c1.call
puts c1.call
puts c1.call
puts c1.call
puts c1.call
Um programa mais simples, que invoca sistemas mais complexos. É um inicializador de um sistema.
In computer programming, a callback is executable code that is passed as an argument to other code.
—Wikipedia: Callback (computer science)
Chamo uma função, que por sua vez tem como parâmetro um callback, isto é, estou passando uma função como parâmetro, que vai ser chamada no escopo da função principal => é um exemplo de callback.
Um cenário: antes de dar um terminate em um aplicativo, quero executar uma rotina que limpe certos traços deixados por ele. Tenho aí um callback, uma função clean_up() por exemplo, que será invocada dentro do exit().
Callback => tradução => "segunda chamada", "chamar de novo"
Em Javascript
funcction doAlert(msg)
{
alert(msg);
}
doAlert(
(function(animal1,animal2) { return animal1 + ' loves ' + animal2; } ) ('cat', 'dog')
);
</script>
Neste contexto, function(animal1, animal2) {} é um callback (e pode ser considerado um lambda também).
No mesmo exemplo pode ser visto um caso de self-invoking function no JS: (function(){})(). A expressão no primeiro grupo de parênteses vai ser processada com os argumentos passados no segundo grupo de parênteses (respectivamente cat e dog).
Significa passar uma informação de uma maneira que seja fácil para persistí-la e/ou resgata-la posteriormente.
Um exemplo é o JSON, um formato de troca de informações amplamente usado para este fim.
????
Capacidade da linguagem onde eu posso no meu código adicionar funcionalidades às classes padrão
exemplo do Float que o Daniel deu, onde ele estendeu a funcionalidade da clase (adicionar código)
=> Lembra o prototype do Javascript.
Códigos que tratam de gerar códigos. Metaprogramação é muito encontrada em Obj-C e Ruby, por exemplo, onde existem uma série de atalhos (metaprogramação) que geram códigos mais extensos "automaticamente", isto é, sem a necessidade do programador ter que escrever tudo aquilo manualmente.
Por exemplo: geração de getters/setters (accessors/mutators) com apenas uma linha de código => é um caso de metaprogramação implementada na linguagem.
Em Ruby:
class Test
attr_accessor :name, :last #metaprogramming
def initialize
self.name = "Primeiro"
self.last = "Último"
end
end
obj = Test.new
puts obj.name
Exemplo: Se o primeiro for false em um AND, nem passa pelo segundo.
Em uma condição de OR, se o primeiro for true, não passa pelo segundo (não faz sentido, por isso economiza esse processamento).
A wrapper function is a function in a computer program whose main purpose is to call a second function with little or no additional computation. This is also known as method delegation. Wrapper functions can be used for a number of purposes.