Adding new class

17.02-Client_Server

@@ -149,3 +149,4 @@ outra:
      |    |              |       |            
      |    |              |       |            
      '----'--------------'       |            
+                                 |

18.01-Client_Server

@@ -0,0 +1,42 @@
+ARQUITETURA CLIENTE-SERVIDOR
+==============================
+
+Em geral, as formas que colocamos na arquitetura da última aula mantém o
+ESTADO salvo dentro do hash dos labels. Porém, essa é uma forma, muitas
+vezes, pouco eficiente: um usuário pode demorar para responder, ou pode
+recarregar uma página web, resolicitar, etc.
+
+Duas soluções, que mantém o estado fora do servidor, são possíveis:
+* Manter o estado na aplicação
+    Usando variáveis escondidas, que não aparecem numa página web, é
+    possível enviar dados e/ou ações pela rede. Este protocolo é SEM 
+    ESTADO: o protocolo não muda de acordo com o que está sendo
+    transferido. Ele apenas transfere informação de um ponto a outro.
+    O estado está nas aplicações (ações feitas), não no protocolo. 
+    Nesse caso, não temos uma tabela que armazena dados/ações. O que
+    precisa ser feito é enviado dentro do protocolo.
+
+* Manter o estado no cliente
+    Usamos o conceito de "cookies". Arquivos disponíveis no navegador 
+    do usuário e que um dado site pode editar. Ele o usa para guardar 
+    as informações dentro do cliente, no momento em que submete um
+    formulário para o servidor. O servidor pode, então, usar estes dados
+    SALVOS no cliente para continuar as ações.
+
+    ; cookies
+    (define cookie '-100)
+
+    (define (read-number/suspend "\nFirst number (cookie)"
+      (lambda (v1)
+        (begin
+          (set! cookie v1)
+          (read-number/suspend "\nSecond number (cookie)"
+                               (lambda (v2) (display (+ cookie v2)))
+      )))
+    ))
+
+    Este é um exemplo de transimissão de informações chamado
+    continuation passing style (CPS). Ele consiste, primariamente, de
+    quebrar uma ação numa sequência de passos. Dado um passo i, ele 
+    executa a computação correspondente a ele e depois envia o restante
+    da operação i+1 para ser executada depois.

18.02-continuation_passing_style

@@ -0,0 +1,55 @@
+CONTINUATION PASSING STYLE
+============================
+
+Este método de computação é o utilizado dentro do esquema
+cliente-servidor (mesmo com suas várias formas de manter o estado). O
+conceito chave é quebrar uma certa computação em uma série de passos
+menores, em que vamos mantendo o "resto" da computação depois da
+operação.
+
+Ex:
+    ; Toda expressão CONSTANTE deve ser quebrada na forma:
+    ; * Constantes cte:
+    ; (λ (resto) (resto cte) )
+
+    - Original:
+    (+ 2 2)
+
+    - CPS:
+    (
+        (λ (resto) (resto 2))
+        (λ (x) (+ x 2))
+    )
+
+Ex:
+    ; Todo LAMBDA deve ser quebrada na forma:
+    ; * Lambdas (λ (arg) (ação arg)):
+    ; (λ (arg resto) (resto (ação arg)) )
+
+    - Original:
+    ((λ (a) (+ (* a 2) b)) 2)
+
+    - CPS:
+    (
+        ; Criamos um lambda com a computação mais interna, (* a 2)
+        ; que é depois aplicada no "resto" da ação.
+        (λ (a, resto) (resto (* a 2)))
+
+        ; O argumento para este lambda são dois valores: o x e o resto.
+        (2 (λ (x) (+ x 5)))
+    )
+
+Para cada tipo de estrutura, quebraríamos de forma diferentes. Essa é
+uma forma de TRANSFORMAÇÃO, em que estamos modificando o programa SEM
+alterar o resultado. A implementação poderia ser feita de duas formas:
+* Açúcar : Usando macros para transformar as sentenças originais;
+* Core   : Modificar o core para implementar esta forma.
+
+Se pegássemos umaexpressão,teríamos a transformação na forma:
+e:    3 * (5 + 2) - 7 * 4
+f(x): 3 * x - 7 * 4         e = f(5+2)
+g(y): y - 7 * 4             e = g(f(5+2))
+...                         ...
+
+Estamos passando o resultado de uma ação para a próxima. Essa é a ideia
+de PILHA DE EXECUÇÃO, como feita em Assembly. Está é a CSP.