Como diz um amigo meu, Haroldo Viegas:
– Pra fotografar desse jeito nem precisava ser cego!

Mário, ascensorista do Edifí­cio Everest (Downtown Curitiba), é cego.

É um homem de cerca de 40 anos, caucasiano, de estatura normal. Usa barba cerrada e suas maçãs-do-rosto são proeminentes. Uma figura simpática e, via de regra, risonha.

Os cegos olhos de Mário – ironia? – são castanhos e expressivos, muito diferente das entristecidas pupilas brancas do imaginário simbólico.

Édipo Rei

Para a maioria das pessoas, é preciso mais de um encontro para notar sua cegueira. Seus sentidos são tão aguçados a ponto deste adivinhar o andar do passageiro mesmo que este emita grunhidos.

Nunca vi Mário de óculos escuros. Uma vez, flagrei-o dobrando sua bengala antes de se instalar em seu posto, onde, durante seis ou sete horas a fio, iria, como todos os dias, apertar botões entre um “bom dia, senhor” ou um “bom dia, senhora”.

Mário está estudando para o vestibular de Direito. Acho que não é a primeira vez que tenta.

Seu método, segundo relata, consiste em digitar – sim, digitar – em um computador o texto das apostilas do cursinho (lidas por sua esposa). A máquina, equipada com um IBM voice ou congênere, cria mí­dia digital audí­vel no ônibus, no descanso, na cama etc.

TALKING MACHINE, utopia recorrente nas invencionices humanas. Para quem NÃO PODE e para quem NÃO QUER ler.

Diferentemente dos cegos bem-lustrados da propaganda oficial, Mário pouco se lixa para as rubras e amarelas pistas taniguchianas que ligam o nada ao lugar algum, aqui na Lindacap. Tampouco se limita a fazer vassouras ou espanadores e vendê-los na Visconde de Guarapuava. Mário quer o mundo, e não se importa se puder apenas tocá-lo.

La canne.

Outro dia, Mário confessou ser um entusiasta do rock e heavy metal dos anos 70. Acha o rock de hoje alienado e pouco criativo. Compra apenas bolachões, em sebos variados. Não perguntei se ele examina a integridade dos seus sulcos ao comprá-los, mas não duvidaria.

Janela da Alma 4×4, fully equiped.
Falando em cegos, esse aí­ é hors-concours.

Sincronicidade ou não, acabo de notar que está a tocar “Canôt find my way home”, do Blind Faith. Parece brincadeira.

OS CEGOS

Contemplai-os minha alma; eis que são pavorosos!
São como manequins, vagamente risí­veis;
E sonâmbulos são, singulares, terrí­veis;
E quem sabe aonde vão seus globos tenebrosos?

Seus olhos, donde a chama eterna é partida,
Como se olhassem longe estão no firmamento;
E não se vê jamais, por sobre o pavimento,
Inclinar vagamente a fronte sucumbida.

Atravessam assim a infinda escuridade,
Esta irmã do silencio imutável, cidade!
Enquanto em torno a nós é um lamento o teu canto

Que é tão atroz que chega a perder-se no orgasmo,
Vê que eu erro também e mais do que eles pasmo,
Digo: “O que pelos céus eles procuram tanto?”

Charles Baudelaire, em julgamento pouco sensí­vel a respeito dos cegos. Original em http://rene.pommier.free.fr/Aveugles.htm)

Estudiosos das epopéias, a questão 4 (http://www.funtrivia.com/playquiz/quiz142895105db10.html) é com vocês.

Algum fotógrafo tem algo a dizer sobre o olhar?

Ciclopes também são bem-vindos. Não hesitem em expor seu, vamos dizer, ponto de vista ‘único’ sobre o olhar.

Não dava para esquecer o velho Ray.

A querida comunidade da Vila da Glória / SC, foi agraciada, por ocasião do quinto centenário da cidade de São Francisco do Sul, em 2004, com uma maravilhosa escultura em bronze e concreto, que, segundo o relato do ilustre artista, escrito nas placas de inauguração, é uma homenagem aos viajantes franceses que ali aportaram em 1842, com a idéia de estabelecer um falanstério em terras brasileiras.
O eminente escultor invocou os druidas ou Netuno (?, o barbudo em bronze) í  frente de uma adorável coisa de concreto que simboliza a árvore da vida, com um espetacular globo terrestre entre seus galhos, simbolizando o conhecimento, junto com quatro prodigiosas máscaras que simbolizam os quatro elementos. Obra prima!
Parece um magní­fico enfeite de carro alegórico de carnaval da Unidos da Vila Xurupita. Custou aos cofres da prefeitura 150 mil reais!
Pouca ou nenhuma importância tem o fato de a Vila não ter saneamento básico para os seus três mil habitantes, nem posto médico decente – o atual recebe a visita de um médico uma vez por semana, não tem remédios o suficiente e nem maca ou ambulância para remoção dos enfermos.
Fato é que nossa querida comunidade ganha com este regalo mais uma grande demonstração de carinho e bom gosto por parte de nossos governantes.
Arte é coisa rara. Valorizem o artista!

Salete Chimulera interpreta Villa lobos no Museu Oscar Niemeyer amanhã, terça-feira dia 13/09 í s 20:33
Performance com projeção de imagens de Wilson Bustolin e dos artistas da EMBAP. Interação mediada por ferramentas de software livre (Demudi / Linux, Pure Data).
::ação agenciamento por orquestra organismo::

penfield o cartógrafo – ”como uma sí­ntese dos seus resultados, ele foi capaz de fazer mapas, que foram denominados de homúnculos corticais (tanto sensoriais quanto motores)- – entre as constatações de Penfield estão as relativas í s gravações neurológicas simultâneas de atos e emoções a eles associadas. Ao estimular o córtex temporal com impulsos elétricos, Penfield descobriu que as pessoas sentiam outra vez a emoção que a situação originalmente lhes havia produzido e que elas estavam conscientes das mesmas interpretações verdadeiras ou falsas que elas próprias deram í  experiência pela primeira vez. Assim, a evocação de recordações pode não ser apenas uma reprodução fotográfica ou fonográfica de cenas e acontecimentos passados, mas a reprodução daquilo que a pessoa viu, ouviu, sentiu e compreendeu, não importa o tempo decorrido da gravação do episódio evocado (W.Penfield e L. Roberts, 1959). Penfield relata inúmeras operações cirúrgicas do cérebro em que pode constatar esse fenômeno, através da excitação elétrica do lobo temporal – – – “

benvindovenido mein robotzzzzzzzzzzz

1. soldenstein Says:
September 12th, 2005 at 9:43 am

Aí­, meu velho amigo Censor:

Apanhei-te, cavaquinho!

2. glerm Says:
September 12th, 2005 at 11:23 am

Continuo dizendo que a Yoko é minha Beatle Preferida.

3. glerm Says:
September 12th, 2005 at 11:24 am

que papo é esse de Censor, com C maiúsculo?
Internet não tem dono não.
Qualquer coisa passa lá em casa.

4. glerm Says:
September 12th, 2005 at 11:25 am

e mais + uma: eu sou o glerm sim, mas pra conferir vai ter que ser olhando no olho.

Benvindos a Internet.

5. Censor Says:
September 12th, 2005 at 11:25 am

Solda, vide comentário abaixo, houve um mal entendido. Censura nunca mais!

Abraço fraterno,

Censorzinho.

6. not Censor == !=ceNsOR Says:

September 12th, 2005 at 11:29 am

!= em c quer dizer “não igual”
== em c quer dizer “igual” ( porque igual é usado para “atribuir valor a” )

agora procurem lá o que quer dizer “peer to peer” ou “p2p”
só pra achar o QUALÉ da intenção

glerm:=Guilherme

7. not Censor == !=ceNsOR Says:

September 12th, 2005 at 11:30 am

;

Salete Chiamulera no MON 13/09/2005 as 20h33
Concerto de abertura do Festival Villa Lobos
Recital de piano com interfaces computacionais em ferramentas livres
Museu Oscar Niemeyer. Rua Marechal Hermes, 999

imagem:: Tatiana Angele

DISTRIBUIÇÃO DE MOEDAS DE UM CENTAVO – 200 unidades.
Ação deflagrada a partir de ORGANISMO 9/9/5

DADOS PESSOAIS DECLARADOS PELOS CONTEMPLADOS:

1. Moeda de 10 centavos;
2. Gravou e subverteu a distribuição de moedas, intensificou a tensão;
3. Estava ao lado do n.ú 2;
4. Quer viver em muitos lugares, declarou estar ao lado de sua namorada;
5. Estava ao lado do n.ú 4;
6. Estava do outro lado do n.ú 4;
7. Estava ao lado do nú 6;
8. Ruan;
9. Namorada de Ruan;
10. Questionou a perenidade da memória;
11. Ambrósio;
12. Foco da subversão do n.ú 5;
13. Descendente de polaco;
14. * Desenrolando fios;
15. Cláudio;
16. Jogamos cara ou coroa (ganhei);
17. * Barba longa;
18. Cartão de visitas 1;
19. Cartão de visitas 2;
20. Devolveu a moeda dizendo: Tenho que trabalhar…
21. Eu te conheço da algum lugar;
22. Signo de Sagitário;
23. Cabelo grisalho;
24. No momento não portava objetos pessoais;
25. Estava de mãos dadas com o n.ú 26;
26. 31;
27. Pablo;
28. Estava com o n.ú27;
29. Isto é uma ação artí­stica? Que estranho!
30. O que é isto? ;
31. * Usava boné;
32. Gosta de roxo;
33. Gosta de vermelho, quer ajudar as pessoas do seu lugar, quer que sua namorada goste mais dele, pediu para ficar com o resto das moedas, Josias.

* Não lembro o que disseram.

O Conceito de Esclarecimento

No sentido mais amplo do progresso do pensamento, o esclarecimento tem perseguido sempre o objectivo de livrar os homens do medo e de investi-los na posição de senhores. Mas a terra totalmente esclarecida resplandece sob o signo de uma calamidade triunfal. O programa do esclarecimento era o desencantamento do mundo. Sua meta era dissolver os mitos e substituir a imaginação pelo saber . Bacon, “o pai da filosofia experimental”, já reunira seus diferentes temas. Ele desprezava os adeptos da tradição, que “primeiro acreditam que os outros sabem o que eles não sabem; e depois que eles próprios sabem o que não sabem. Contudo, a credulidade, a aversão í  dúvida, a temeridade no responder, o vangloriar-se com o saber , a timidez no contradizer, o agir por interesse, a preguiça nas investigações pessoais, o fetichismo verbal, o deter-se em conhecimentos parciais: isto e coisas semelhantes impediram um casamento feliz do entendimento humano com a natureza das coisas e o acasalaram, em vez disso, a conceitos vãos e experimentos erráticos; o fruto e a posteridade de tão gloriosa união pode-se facilmente imaginar. A imprensa não passou de uma invenção grosseira; o canhão era uma invenção que já estava praticamente assegurada; a bússola já era, até certo ponto, conhecida…

Theodor W. Adorno

Sifu! Sifu! Sifu! Sifu! Sifu! Sifu! Sifu!

vamo lá! aplauso. 26 de maio, aplauso. começa aqui? ó o fiscal! já tem alguma coisa pra esquentá! um abraço.. é a borboleta 13, corre hoje! vocês são loucos! eu vou seguir vocês ate onde vocês forem. é ator!, é ator!. surdo você não é. péra aí­, deixa eu ver se eu descubro alguma coisa, eu vou ficar junto,

.

não! quero saber! artistas vocês são para fazer isso! de curitiba? voces são de curitiba? eu tô bêbada! são paulo? você é do rio de janeiro? alguma coisa que vocês aplaudem? atores? algum tipo de artista? artista plástico? a gente bebe pra esquentar no frio. mas eu goxtei. vocês tão indo longe. eu vou bater palma também! Eu quero entender. aí­ sérgião, beleza? então voce é músico! sergião, tá dificil a situação aqui. eu já andei mais do que eu devia andar. punks da xv são gente também.

agora vocé, serginho. você vai me dizer se você é de curitiba ou não. eu sou do rio. você tem 27 anos? eu tô bêbada mas eu tenho consciência das coisas que eu tô fazendo. luta de classes. lutando contra o facismo, contra a guerra. eu tenho certeza que vocês tão fazendo isso por que eu estou bêbada demais. vou me despedir, assim. parabéns, tchau!

muito bem, muito bem, vamos ao cafézinho…

C

 /*
  *  linux/init/main.c
  *
  *  Copyright (C) 1991, 1992  Linus Torvalds

  *
  *  GK 2/5/95  -  Changed to support mounting root fs via NFS
  *  Added initrd & change_root: Werner Almesberger & Hans Lermen, Feb '96

  *  Moan early if gcc is old, avoiding bogus kernels - Paul Gortmaker, May '96
  *  Simplified starting of init:  Michael A. Griffith <grif@acm.org> 
  */

 
 #define __KERNEL_SYSCALLS__
 
 #include <linux/config.h>
 #include <linux/types.h>

 #include <linux/module.h>
 #include <linux/proc_fs.h>
 #include <linux/devfs_fs_kernel.h>
 #include <linux/kernel.h>

 #include <linux/syscalls.h>
 #include <linux/string.h>
 #include <linux/ctype.h>
 #include <linux/delay.h>

 #include <linux/utsname.h>
 #include <linux/ioport.h>
 #include <linux/init.h>
 #include <linux/smp_lock.h>

 #include <linux/initrd.h>
 #include <linux/hdreg.h>
 #include <linux/bootmem.h>
 #include <linux/tty.h>

 #include <linux/gfp.h>
 #include <linux/percpu.h>
 #include <linux/kmod.h>
 #include <linux/kernel_stat.h>

 #include <linux/security.h>
 #include <linux/workqueue.h>
 #include <linux/profile.h>
 #include <linux/rcupdate.h>

 #include <linux/moduleparam.h>
 #include <linux/kallsyms.h>
 #include <linux/writeback.h>
 #include <linux/cpu.h>

 #include <linux/efi.h>
 #include <linux/unistd.h>
 #include <linux/rmap.h>
 #include <linux/mempolicy.h>

 #include <linux/key.h>
 
 #include <asm/io.h>
 #include <asm/bugs.h>

 #include <asm/setup.h>
 
 /*
  * This is one of the first .c files built. Error out early
  * if we have compiler trouble..

  */
 #if __GNUC__ == 2 && __GNUC_MINOR__ == 96
 #ifdef CONFIG_FRAME_POINTER
 #error This compiler cannot compile correctly with frame pointers enabled

 #endif
 #endif
 
 #ifdef CONFIG_X86_LOCAL_APIC
 #include <asm/smp.h>
 #endif

 
 /*
  * Versions of gcc older than that listed below may actually compile
  * and link okay, but the end product can have subtle run time bugs.
  * To avoid associated bogus bug reports, we flatly refuse to compile

  * with a gcc that is known to be too old from the very beginning.
  */
 #if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 95)

 #error Sorry, your GCC is too old. It builds incorrect kernels.
 #endif
 
 static int init(void *);
 
 extern void init_IRQ(void);

 extern void sock_init(void);
 extern void fork_init(unsigned long);
 extern void mca_init(void);
 extern void sbus_init(void);

 extern void sysctl_init(void);
 extern void signals_init(void);
 extern void buffer_init(void);
 extern void pidhash_init(void);

 extern void pidmap_init(void);
 extern void prio_tree_init(void);
 extern void radix_tree_init(void);
 extern void free_initmem(void);

 extern void populate_rootfs(void);
 extern void driver_init(void);
 extern void prepare_namespace(void);
 #ifdef  CONFIG_ACPI

 extern void acpi_early_init(void);
 #else
 static inline void acpi_early_init(void) { }
 #endif
 

 #ifdef CONFIG_TC
 extern void tc_init(void);
 #endif
 
 enum system_states system_state;

 EXPORT_SYMBOL(system_state);
 
 /*
  * Boot command-line arguments

  */
 #define MAX_INIT_ARGS 32
 #define MAX_INIT_ENVS 32

 
 extern void time_init(void);
 /* Default late time init is NULL. archs can override this later. */
 void (*late_time_init)(void);
 extern void softirq_init(void);

 
 /* Untouched command line (eg. for /proc) saved by arch-specific code. */
 char saved_command_line[COMMAND_LINE_SIZE];
 
 static char *execute_command;

 
 /* Setup configured maximum number of CPUs to activate */
 static unsigned int max_cpus = NR_CPUS;
 
 /*

  * Setup routine for controlling SMP activation
  *
  * Command-line option of "nosmp" or "maxcpus=0" will disable SMP
  * activation entirely (the MPS table probe still happens, though).

  *
  * Command-line option of "maxcpus=<NUM>", where <NUM> is an integer
  * greater than 0, limits the maximum number of CPUs activated in

  * SMP mode to <NUM>.
  */
 static int __init nosmp(char *str)

 {
         max_cpus = 0;
         return 1;
 }
 
 __setup("nosmp", nosmp);

 
 static int __init maxcpus(char *str)
 {
         get_option(&str, &max_cpus);

         return 1;
 }
 
 __setup("maxcpus=", maxcpus);
 

 static char * argv_init[MAX_INIT_ARGS+2] = { "init", NULL, };
 char * envp_init[MAX_INIT_ENVS+2] = { "HOME=/", "TERM=linux", NULL, };

 static const char *panic_later, *panic_param;
 
 extern struct obs_kernel_param __setup_start[], __setup_end[];

 
 static int __init obsolete_checksetup(char *line)
 {
         struct obs_kernel_param *p;

 
         p = __setup_start;
         do {
                 int n = strlen(p->str);

                 if (!strncmp(line, p->str, n)) {
                         if (p->early) {

                                 /* Already done in parse_early_param?  (Needs
                                  * exact match on param part) */
                                 if (line[n] == '\0' || line[n] == '=')

                                         return 1;
                         } else if (!p->setup_func) {
                                 printk(KERN_WARNING "Parameter %s is obsolete,"

                                        " ignored\n", p->str);
                                 return 1;
                         } else if (p->setup_func(line + n))

                                 return 1;
                 }
                 p++;
         } while (p < __setup_end);

         return 0;
 }
 
 /*
  * This should be approx 2 Bo*oMips to start (note initial shift), and will

  * still work even if initially too large, it will just take slightly longer
  */
 unsigned long loops_per_jiffy = (1<<12);

 
 EXPORT_SYMBOL(loops_per_jiffy);
 
 static int __init debug_kernel(char *str)

 {
         if (*str)
                 return 0;
         console_loglevel = 10;
         return 1;

 }
 
 static int __init quiet_kernel(char *str)
 {

         if (*str)
                 return 0;
         console_loglevel = 4;
         return 1;
 }

 
 __setup("debug", debug_kernel);
 __setup("quiet", quiet_kernel);

 
 /*
  * Unknown boot options get handed to init, unless they look like
  * failed parameters
  */

 static int __init unknown_bootoption(char *param, char *val)
 {
         /* Change NUL term back to "=", to make "param" the whole string. */

         if (val) {
                 /* param=val or param="val"? */
                 if (val == param+strlen(param)+1)

                         val[-1] = '=';
                 else if (val == param+strlen(param)+2) {

                         val[-2] = '=';
                         memmove(val-1, val, strlen(val)+1);

                         val--;
                 } else
                         BUG();
         }
 
         /* Handle obsolete-style parameters */

         if (obsolete_checksetup(param))
                 return 0;
 
         /*
          * Preemptive maintenance for "why didn't my mispelled command

          * line work?"
          */
         if (strchr(param, '.') && (!val || strchr(param, '.') < val)) {

                 printk(KERN_ERR "Unknown boot option `%s': ignoring\n", param);
                 return 0;
         }
 

         if (panic_later)
                 return 0;
 
         if (val) {
                 /* Environment option */

                 unsigned int i;
                 for (i = 0; envp_init[i]; i++) {

                         if (i == MAX_INIT_ENVS) {
                                 panic_later = "Too many boot env vars at `%s'";
                                 panic_param = param;

                         }
                         if (!strncmp(param, envp_init[i], val - param))

                                 break;
                 }
                 envp_init[i] = param;
         } else {

                 /* Command line option */
                 unsigned int i;
                 for (i = 0; argv_init[i]; i++) {

                         if (i == MAX_INIT_ARGS) {
                                 panic_later = "Too many boot init vars at `%s'";
                                 panic_param = param;

                         }
                 }
                 argv_init[i] = param;
         }

         return 0;
 }
 
 static int __init init_setup(char *str)

 {
         unsigned int i;
 
         execute_command = str;

         /*
          * In case LILO is going to boot us with default command line,
          * it prepends "auto" before the whole cmdline which makes
          * the shell think it should execute a script with such name.

          * So we ignore all arguments entered _before_ init=... [MJ]
          */
         for (i = 1; i < MAX_INIT_ARGS; i++)

                 argv_init[i] = NULL;
         return 1;
 }
 __setup("init=", init_setup);

 
 extern void setup_arch(char **);
 
 #ifndef CONFIG_SMP
 
 #ifdef CONFIG_X86_LOCAL_APIC

 static void __init smp_init(void)
 {
         APIC_init_uniprocessor();
 }

 #else
 #define smp_init()      do { } while (0)
 #endif
 
 static inline void setup_per_cpu_areas(void) { }

 static inline void smp_prepare_cpus(unsigned int maxcpus) { }
 
 #else
 
 #ifdef __GENERIC_PER_CPU

 unsigned long __per_cpu_offset[NR_CPUS];
 
 EXPORT_SYMBOL(__per_cpu_offset);
 

 static void __init setup_per_cpu_areas(void)
 {
         unsigned long size, i;

         char *ptr;
         /* Created by linker magic */
         extern char __per_cpu_start[], __per_cpu_end[];
 

         /* Copy section for each CPU (we discard the original) */
         size = ALIGN(__per_cpu_end - __per_cpu_start, SMP_CACHE_BYTES);

 #ifdef CONFIG_MODULES
         if (size < PERCPU_ENOUGH_ROOM)
                 size = PERCPU_ENOUGH_ROOM;

 #endif
 
         ptr = alloc_bootmem(size * NR_CPUS);

 
         for (i = 0; i < NR_CPUS; i++, ptr += size) {

                 __per_cpu_offset[i] = ptr - __per_cpu_start;
                 memcpy(ptr, __per_cpu_start, __per_cpu_end - __per_cpu_start);

         }
 }
 #endif /* !__GENERIC_PER_CPU */
 
 /* Called by boot processor to activate the rest. */

 static void __init smp_init(void)
 {
         unsigned int i;
 

         /* FIXME: This should be done in userspace --RR */
         for_each_present_cpu(i) {
                 if (num_online_cpus() >= max_cpus)

                         break;
                 if (!cpu_online(i))
                         cpu_up(i);
         }

 
         /* Any cleanup work */
         printk("Brought up %ld CPUs\n", (long)num_online_cpus());
         smp_cpus_done(max_cpus);

 #if 0
         /* Get other processors into their bootup holding patterns. */
 
         smp_threads_ready=1;
         smp_commence();
 #endif

 }
 
 #endif
 
 /*
  * We need to finalize in a non-__init function or else race conditions

  * between the root thread and the init thread may cause start_kernel to
  * be reaped by free_initmem before the root thread has proceeded to
  * cpu_idle.
  *

  * gcc-3.4 accidentally inlines this function, so use noinline.
  */
 
 static void noinline rest_init(void)

         __releases(kernel_lock)
 {
         kernel_thread(init, NULL, CLONE_FS | CLONE_SIGHAND);

         numa_default_policy();
         unlock_kernel();
         preempt_enable_no_resched();
         cpu_idle();
 } 

 
 /* Check for early params. */
 static int __init do_early_param(char *param, char *val)

 {
         struct obs_kernel_param *p;
 
         for (p = __setup_start; p < __setup_end; p++) {

                 if (p->early && strcmp(param, p->str) == 0) {
                         if (p->setup_func(val) != 0)

                                 printk(KERN_WARNING
                                        "Malformed early option '%s'\n", param);
                 }
         }

         /* We accept everything at this stage. */
         return 0;
 }
 
 /* Arch code calls this early on, or if not, just before other parsing. */
 void __init parse_early_param(void)

 {
         static __initdata int done = 0;
         static __initdata char tmp_cmdline[COMMAND_LINE_SIZE];

 
         if (done)
                 return;
 
         /* All fall through to do_early_param. */
         strlcpy(tmp_cmdline, saved_command_line, COMMAND_LINE_SIZE);

         parse_args("early options", tmp_cmdline, NULL, 0, do_early_param);
         done = 1;
 }

 
 /*
  *      Activate the first processor.
  */
 

 asmlinkage void __init start_kernel(void)
 {
         char * command_line;

         extern struct kernel_param __start___param[], __stop___param[];
 /*
  * Interrupts are still disabled. Do necessary setups, then

  * enable them
  */
         lock_kernel();
         page_address_init();

         printk(linux_banner);
         setup_arch(&command_line);
         setup_per_cpu_areas();
 

         /*
          * Mark the boot cpu "online" so that it can call console drivers in
          * printk() and can access its per-cpu storage.
          */

         smp_prepare_boot_cpu();
 
         /*
          * Set up the scheduler prior starting any interrupts (such as the
          * timer interrupt). Full topology setup happens at smp_init()

          * time - but meanwhile we still have a functioning scheduler.
          */
         sched_init();
         /*

          * Disable preemption - early bootup scheduling is extremely
          * fragile until we cpu_idle() for the first time.
          */
         preempt_disable();

         build_all_zonelists();
         page_alloc_init();
         printk("Kernel command line: %s\n", saved_command_line);
         parse_early_param();

         parse_args("Booting kernel", command_line, __start___param,
                    __stop___param - __start___param,

                    &unknown_bootoption);
         sort_main_extable();
         trap_init();
         rcu_init();
         init_IRQ();

         pidhash_init();
         init_timers();
         softirq_init();
         time_init();
 

         /*
          * HACK ALERT! This is early. We're enabling the console before
          * we've done PCI setups etc, and console_init() must be aware of
          * this. But we do want output early, in case something goes wrong.

          */
         console_init();
         if (panic_later)
                 panic(panic_later, panic_param);

         profile_init();
         local_irq_enable();
 #ifdef CONFIG_BLK_DEV_INITRD
         if (initrd_start && !initrd_below_start_ok &&

                         initrd_start < min_low_pfn << PAGE_SHIFT) {
                 printk(KERN_CRIT "initrd overwritten (0x%08lx < 0x%08lx) - "

                     "disabling it.\n",initrd_start,min_low_pfn << PAGE_SHIFT);
                 initrd_start = 0;
         }

 #endif
         vfs_caches_init_early();
         mem_init();
         kmem_cache_init();
         numa_policy_init();

         if (late_time_init)
                 late_time_init();
         calibrate_delay();
         pidmap_init();

         pgtable_cache_init();
         prio_tree_init();
         anon_vma_init();
 #ifdef CONFIG_X86
         if (efi_enabled)

                 efi_enter_virtual_mode();
 #endif
         fork_init(num_physpages);
         proc_caches_init();

         buffer_init();
         unnamed_dev_init();
         security_init();
         vfs_caches_init(num_physpages);

         radix_tree_init();
         signals_init();
         /* rootfs populating might need page-writeback */
         page_writeback_init();
 #ifdef CONFIG_PROC_FS

         proc_root_init();
 #endif
         check_bugs();
 
         acpi_early_init(); /* before LAPIC and SMP init */

 
         /* Do the rest non-__init'ed, we're now alive */
         rest_init();
 }
 
 static int __initdata initcall_debug;

 
 static int __init initcall_debug_setup(char *str)
 {
         initcall_debug = 1;

         return 1;
 }
 __setup("initcall_debug", initcall_debug_setup);
 
 struct task_struct *child_reaper = &init_task;

 
 extern initcall_t __initcall_start[], __initcall_end[];
 
 static void __init do_initcalls(void)

 {
         initcall_t *call;
         int count = preempt_count();
 

         for (call = __initcall_start; call < __initcall_end; call++) {
                 char *msg;
 
                 if (initcall_debug) {

                         printk(KERN_DEBUG "Calling initcall 0x%p", *call);
                         print_fn_descriptor_symbol(": %s()", (unsigned long) *call);
                         printk("\n");

                 }
 
                 (*call)();
 
                 msg = NULL;

                 if (preempt_count() != count) {
                         msg = "preemption imbalance";
                         preempt_count() = count;

                 }
                 if (irqs_disabled()) {
                         msg = "disabled interrupts";
                         local_irq_enable();

                 }
                 if (msg) {
                         printk("error in initcall at 0x%p: "
                                 "returned with %s\n", *call, msg);

                 }
         }
 
         /* Make sure there is no pending stuff from the initcall sequence */
         flush_scheduled_work();
 }

 
 /*
  * Ok, the machine is now initialized. None of the devices
  * have been touched yet, but the CPU subsystem is up and
  * running, and memory and process management works.

  *
  * Now we can finally start doing some real work..
  */
 static void __init do_basic_setup(void)

 {
         /* drivers will send hotplug events */
         init_workqueues();
         usermodehelper_init();
         key_init();

         driver_init();
 
 #ifdef CONFIG_SYSCTL
         sysctl_init();
 #endif

 
         /* Networking initialization needs a process context */ 
         sock_init();
 
         do_initcalls();
 }

 
 static void do_pre_smp_initcalls(void)
 {
         extern int spawn_ksoftirqd(void);
 #ifdef CONFIG_SMP

         extern int migration_init(void);
 
         migration_init();
 #endif
         spawn_ksoftirqd();

 }
 
 static void run_init_process(char *init_filename)
 {
         argv_init[0] = init_filename;

         execve(init_filename, argv_init, envp_init);
 }
 
 static inline void fixup_cpu_present_map(void)

 {
 #ifdef CONFIG_SMP
         int i;
 
         /*

          * If arch is not hotplug ready and did not populate
          * cpu_present_map, just make cpu_present_map same as cpu_possible_map
          * for other cpu bringup code to function as normal. e.g smp_init() etc.
          */

         if (cpus_empty(cpu_present_map)) {
                 for_each_cpu(i) {
                         cpu_set(i, cpu_present_map);

                 }
         }
 #endif
 }
 
 static int init(void * unused)

 {
         lock_kernel();
         /*
          * Tell the world that we're going to be the grim
          * reaper of innocent orphaned children.

          *
          * We don't want people to have to make incorrect
          * assumptions about where in the task array this
          * can be found.

          */
         child_reaper = current;
 
         /* Sets up cpus_possible() */

         smp_prepare_cpus(max_cpus);
 
         do_pre_smp_initcalls();
 
         fixup_cpu_present_map();

         smp_init();
         sched_init_smp();
 
         /*
          * Do this before initcalls, because some drivers want to access

          * firmware files.
          */
         populate_rootfs();
 
         do_basic_setup();

 
         /*
          * check if there is an early userspace init.  If yes, let it do all
          * the work
          */

         if (sys_access((const char __user *) "/init", 0) == 0)
                 execute_command = "/init";

         else
                 prepare_namespace();
 
         /*
          * Ok, we have completed the initial bootup, and

          * we're essentially up and running. Get rid of the
          * initmem segments and start the user-mode stuff..
          */
         free_initmem();

         unlock_kernel();
         system_state = SYSTEM_RUNNING;
         numa_default_policy();
 
         if (sys_open((const char __user *) "/dev/console", O_RDWR, 0) < 0)

                 printk("Warning: unable to open an initial console.\n");
 
         (void) sys_dup(0);
         (void) sys_dup(0);

         
         /*
          * We try each of these until one succeeds.
          *
          * The Bourne shell can be used instead of init if we are 

          * trying to recover a really broken machine.
          */
 
         if (execute_command)

                 run_init_process(execute_command);
 
         run_init_process("/sbin/init");
         run_init_process("/etc/init");

         run_init_process("/bin/init");
         run_init_process("/bin/sh");
 
         panic("No init found.  Try passing init= option to kernel.");

 }
 

Num dado momento da vida, células individuais não mais se separam, depois de terem se dividido. Assim surgiu um super ser que não é mais famí­lia de seres, (como algas, primeiras tentativas na direção apontada) mas um novo Eu. Dizem os biólogos que são processos bio-quí­micos que produzem essa ligação intercelular nova. Mas a nossa imaginação se recusa a imaginar processos “bioquí­micos” que resultam, por assim dizer exotermicamente, em novo Eu. Na transição dos protozoários para os metazoários houve, evidentemente, um novo saldo de camada de realidade. As sociedades que assim surgiram estão em estado de equilí­brio ainda muito mais precário que os protozoários. São seres mortais, justamente poque é precário o equilí­brio no qual se encontram. As células que formam o organismo contribuem para o seu funcionamento na base de uma divisão de trabalho. Assumem papéis variados da economia do organismo. É por isto que épocas mais otimistas encararam o organismo como uma espécie de cooperativa. Mas o nosso conhecimento mais exato não admite essa descrição otimista. A divisão de trabalho entre as células no organismo é muito imprecisa, e há, além disso, uma constante luta entre elas. A inexatidão da divisão de trabalho, e a luta entre as células chama-se “doença”. Devemos portanto dizer que, mais que cooperativa, é o organismo um campo de luta. Quando o governo do organismo, a “alma” perde o controle da luta, surge a morte. Os organismos são portanto, pelo seu projeto, não somente seres mortais mas ainda seres doentes.

FLUSSER, Vilém. A história do diabo. São Paulo: Martins, 1965.

Célula-Colaborativa João Debs-Giselle

surface-interface-action

JURAMENTO DE HIPÂCRATES

” Eu juro, por Apolo, médico, por Esculápio, Higeia e Panacea, e tomo por testemunhas todos os deuses e todas as deusas, cumprir, segundo meu poder e minha razão, a promessa que se segue: estimar, tanto quanto a meus pais, aquele que me ensinou esta arte; fazer vida comum e, se necessário for, com ele partilhar meus bens; ter seus filhos por meus próprios irmãos; ensinar-lhes esta arte, se eles tiverem necessidade de aprendê-la, sem remuneração e nem compromisso escrito; fazer participar dos preceitos, das lições e de todo o resto do ensino, meus filhos, os de meu mestre e os discí­pulos inscritos segundo os regulamentos da profissão, porém, só a estes.

Aplicarei os regimes para o bem do doente segundo o meu poder e entendimento, nunca para causar dano ou mal a alguém. A ninguém darei por comprazer, nem remédio mortal nem um conselho que induza a perda. Do mesmo modo não darei a nenhuma mulher uma substância abortiva.

Conservarei imaculada minha vida e minha arte.

Não praticarei a talha, mesmo sobre um calculoso confirmado; deixarei essa operação aos práticos que disso cuidam.

Em toda a casa, aí­ entrarei para o bem dos doentes, mantendo-me longe de todo o dano voluntário e de toda a sedução sobretudo longe dos prazeres do amor, com as mulheres ou com os homens livres ou escravizados.

àquilo que no exercí­cio ou fora do exercí­cio da profissão e no conví­vio da sociedade, eu tiver visto ou ouvido, que não seja preciso divulgar, eu conservarei inteiramente secreto.

Se eu cumprir este juramento com fidelidade, que me seja dado gozar felizmente da vida e da minha profissão, honrado para sempre entre os homens; se eu dele me afastar ou infringir, o contrário aconteça.”
Hipócrates

Moto Contí­nuo — O que é?

Um moto-contí­nuo seria uma máquina que operaria indefinidamente, sem consumo de energia ou ação externa, apenas por conversões internas de energia, ou seja, uma máquina totalmente conservativa, o que segundo os fí­sicos não poderia existir porque toda máquina sempre dissipa energia, por menor que seja, mas dissipa. E essa energia perdida pode ser liberada em forma de calor, som, luz e etc.