Tengo que decir que "The Joker" se llevo la pelicula, es una lastima que Heath Ledger este muerto, por que sera muy dificil sustituir su talento con el que dio vida a este personaje. deja mucho en que pensar y creo que muchos niños de la sala salieron pensando que seria mejor ser un "Joker" que Batman.

«La locura es como la gravedad, ¿sabes? Todo lo que hace falta es un pequeño empujón».

 

En la ultima entrada, aprendimos a declarar y usar funciones, hoy profundizaremos un poco en como se utilizan las variables en las funciones y su alcance.

Veamos una variable dentro de una función es privada (o local) a ella, debido a que esta declarada dentro de una función, ninguna otra función puede tener acceso "directo" a ellas. Estas variables se llaman automáticas y "existen" cuando la función es llamada y dejan de "existir" cuando la función termina, nota que como las variables locales aparecen y desaparecen con las invocaciones a funciones, no retienen valores entre llamadas sucesivas.

Si queremos que se guarden valores entre llamadas podremos hacer algunas cosas como variables externas, esto tiene ventajas como que la variable no se destruye, podremos comunicar datos entre funciones sin necesidad de listar sus argumentos, pero de cara a la seguridad no es muy buena idea (son como variables "Public"  en POO), tampoco ayuda a la reutilización de código nos podemos ingeniar para hacerlo, es mejor desde mi humilde punto de vista el uso de variables estáticas, pero expliquemos las variables externas.

Las variables externas se definen solo una vez, fuera de cualquier función, además debe ser declarada en cada función en la que se use y debe contener la proposición extern. Admito que muchas veces esta declaración extern se omite por que las variables comúnmente se declaran en el mismo archivo fuente que las funciones que las ocupan, entonces, se puede omitir en estos casos.

La otra forma de mantener los valores entre llamadas es declarando variables estáticas, estas no se destruyen entre llamados, permanecen en memoria hasta que termina la ejecución del programa, se declaran dentro de la función como static Tipo NombreVariable. Veamos un ejemplo para que todo quede mas claro.

/******************* Archivo fun.h***********************************************************************/

#include<stdio.h>
/*
 *Variable externa, la inicial F de las funciones significa
 *(para este caso particular, claro)
 *que no forman parte del archivo con la funcion "main" ..
 */
int FVarExterna=10;

/*
 *Definicion de la funciones VarEst e ImprimeValores
 */
int FVarEst(int anyval);
void ImprimeVal(int val);

/*
 *Funcion que recibe un entero y lo suma a la variable estatica
 *de la funcion. Regresa el valor almacenado en la variable estatica.
 */

int FVarEst(int anyval){
static int FVarSt=0;
FVarSt+=anyval;
return FVarSt;
}
/*
 *Funcion que imprime en la salida estandar el Num. entero recibido.
 */
void ImprimeVal(int val){
printf("\nValor: %d\n",val);
}
 

/***************************************Archivo Variables.c***************************************************/

#include"fun.h"
#define MAX 16

/*
 *Definicion de la funcion funlocal, muestra el uso de una variable
 *local a ella que no guada valores entre llamadas
 */
int funlocal(int a);

//Inicia funcion principal
int main(){
int i;

printf("Variable Externa \'FVarExterna\'\n");
ImprimeVal(FVarExterna);
printf("Variable Estatica \'FVarEst\'\n");
ImprimeVal(FVarEst(0));
printf("Variable Externa \'i de la funcion funlocal\'\n");
ImprimeVal(funlocal(0));

for(i=0;i<MAX;i++){
    printf("\'i de funcion main\'%d\n",i);
    printf("Variable Externa \'FVarExterna\' + %d\n");

    FVarExterna+=i;

    ImprimeVal(FVarExterna);
    printf("Variable Estatica \'FVarEst\' + %d\n");
    ImprimeVal(FVarEst(i));
    printf("Variable Externa \'i de la funcion funlocal\' + %d\n");
    ImprimeVal(funlocal(i));
    }
       
return 0;
}//fin de la funcion principal

int funlocal(int a){
int i=0;
i+=a;
return i;
}
 

/*************************************************************************************************/

$gcc variables.c -o variables

$./variables

Como notamos es posible tener varias variables con el mismo nombre en funciones diferentes, esto es por que solo son locales a la función, sin embargo podemos hacer referencia a la variable global en cualquier lugar del programa.

La salida del programa puede servir de referencia para entender como funciona el uso de las variables, nota que no se puede acceder a una variable local, como por ejemplo:

Desde main():

printf("Variable estatica FVarEst : %d",FVarEst);  es una operacion ilegal.

Espero que los resultados sean claros y cualquier duda o aclaración la resuelvo en los comentarios en los comentarios.

Un poco de musica, de esa que siempre te recuerda a alguien.

saludos.

De la Siempre Genial tira xkcd:

Se trata de un trabajo que lei hace ya algun tiempo, trato de desarrollar la idea "a mi manera", pero antes eres Humano????

Según la Wikipedia:

"Captcha es el acrónimo de Completely Automated Public Turing test to tell Computers and Humans Apart (Prueba de Turing pública y automática para diferenciar a máquinas y humanos).

Se trata de una prueba desafío-respuesta utilizada en computación para determinar cuándo el usuario es o no humano.

La típica prueba consiste en que el usuario introduzca un conjunto de caracteres que se muestran en una imagen distorsionada que aparece en pantalla. Se supone que una máquina no es capaz de comprender e introducir la secuencia de forma correcta por lo que solamente el humano podría hacerlo (salvo error)"

Continua...

"Oí que se resuelven unos 60 millones de CAPTCHAs cada día en todo el mundo. Si se necesitan unos diez segundos para cada uno, eso quiere decir que la humanidad está desperdiciando miles de horas resolviéndolos. Y pensé que se podría hacer algo bueno para la humanidad con todo ese tiempo."

Es muy cierto que las computadoras son limitadas en lo que pueden hacer, los capchas han evolucionado para ser mas difíciles de resolver por técnicas computacionales, tomando un poco la idea del profesor Luis Von Ahn (cita de arriba) se podrian utilizar los capchas para tareas que a las computadoras les sea imposible resolver (o muy costoso en tiempo y calculos), un ejemplo sencillo de implementar seria la clasificación de imágenes, mismas que serian usadas por ejemplo para personas con alguna discapacidad visual. Digamos que tenemos dos grupos de imágenes (I & M) unas que se conoce que objeto representan y otro desconocido y que en una pagina se inserta una imagen (pseudo) aleatoriamente a manera de capcha, el usuario tendrá que resolver correctamente el capcha pues desconoce si es una capcha real o solo etiqueta una imagen, es claro que la dimensión de los grupos debe ser calculada de tal forma que por pura combinatoria  la probabilidad de que se acierte ingresando caracteres al azar sea muy pequeña, ademas los errores se pueden descartar fácilmente por puro análisis estadístico (digamos que una imagen fue contestada 30 veces como gato y una como pato, se descarta pato).

Es claro que la clasificación no es la única aplicación de esta idea, se me ocurre que debido a la amplitud de la internet y su gran variedad de comunidades especializadas podrían hacer muchas cosas acorde al conocimiento particular de cada comunidad. (¿que clase de problemas resolvería un mononeuron?)

Por ejemplo se podrían hacer traducciones textos mas cercanas al lenguaje y no como "Toro del Llanero solitario", se podria aprovechar la inclinación técnica o científica de un grupo para resolver cierto problemas algo mas complejos como:


Aunque es claro que lo ideal seria intentar cosas mucho mas interesantes que este ultimo, digamos este:



Por ultimo y Como nota anecdótica, el nombre Soylent Grid es por supuesto una referencia a la película de ciencia-ficción Soylent Green (”Cuando el destino nos alcance“). Y es que el ingrediente básico tanto de la supuesta comida a base de plancton que da el nombre a la película, como de la red computacional que en este caso se usaría es el mismo.

Bueno el texto original esta aqui para su descarga y critica.

Llueve horrible y no puedo evitar sentirme algo nostalgico

y triste.

Si te dedicas a diseñar software o cualquier otra cosa, esto te parecerá un deja vu


Gracias a dios, me gusta mas el computo científico.

Edsger W. Dijkstra es uno de los grandes maestros de las Ciencias de la Computación. Sería imposible resumir en poco espacio los aportes realizados por este físico devenido en informático, los cuales no se limitaron a cuestiones "técnicas", sino también al avance de la computación como ciencia.

Les comparto un texto (ingles)que vale mucho la pena leer, se trata de una critica de E. W. Dijkstra sobre los metodos de enseñanza de programacion, es verdaderamente interesante, algo denso si no se esta preparado, pero facil de entender con una mente mas despierta (entonces lo mononeurones no tienen problema).

Me permito traducir una linea para animar un poco a la lectura:

"Mi punto hoy es que, si deseamos contar las lineas de codigo, no deberi­amos verlas como lineas "producidas", sino como lineas "gastadas" "

Mi modesta y muy personal interpretacion de esto viene del siguiente razonamiento:

Como el mortal que soy, solo puedo escribir un numero limitados de lineas de codigo 'N', N puede ser un numero muy grande o muy pequeño y para algunos incluso 0.

Lo importante es darse cuenta que de ninguna manera es infinito, como nos afrontamos a esto:

Escribiendo programas donde cada linea valga la pena como para ser gastada, no necesariamente tenemos que hacer programas mas cortos, es bien sabido que el "Bubble Sort" es muy corto, sencillo de programar, pero es terriblemente ineficiente, podriamos mejorarlo si en vez de usar datos como tal, usamos apuntadores en un arreglo, solo tendremos que intercambiar apuntadores, en vez de mover datos completos. sin embargo eso tambien lo podri­amos hacer con un "Quick Sort" lo que seria mucho mas rapido, elegante y eficiente, cierto mas largo, sin duda cada una de esas lineas vale la pena y corremos menos riesgos de que en algunos años vomitemos al ver ese codigo.

y traduzco otra mas:

"La tarea del programador es presentar las conjeturas completas como teoremas demostrados"

Algo que jamas debemos olvidar, es que nuestro lenguaje de programacion favorito (C/C++, Python, Scheme,Haskell, C#, java, fuckbrain, perl,etc) es un sistema formal creado a partir de los modelos creados por Alan Turing (Maquinas de Turing) y/o Alonzo Church (Calculo Lambda), el fin de estos metodos es identificar claramente (Formalmente dicho de manera mas apropiada) que funciones son computables y cuales no. Entonces un programa que resuelve un problema esta definido en base a un sistema formal y puede verse como una funcion larga o un subconjunto de funciones para que demuestran que el problema resuelto es computable.

Brevemente : la cantidad de problemas a resolver en el universo de problemas es mucho mas grande que el de las funciones computables existentes.

Espero se animen a la lectura. aqui de nuevo el texto

Encontré esta maravilla gracias a la wikipedia licencia CC:


Descargala en pdf para imprimir aqui.