Vim esta claro que es uno de los mejores editores que existen. Y también es una de las mejores herramientas para programar o hacer scripts.

Para mi, el esquema de colores es muy importante. Prefiero un esquema oscuro, me siento muy cómodo programando en un ambiente que no lastime mis ojos. Encontré una página con algunos scheme de vim que se podrían probar. La mayoria funcionan solo funcionarian correctamente en gvim.

Mis favoritos son, astronaut, black_angus, blue_green, candy_code y darkzen.

Entonces como solo se pueden probar correctamente en gvim, podemos hacer que gvim parezca mas consola y menos aplicación grafica, modificando el .vimrc.


colorscheme candycode
set guioptions-=T


La primera linea pone candycode como scheme por defecto y la segunda quita la fea barra de herramientas que solamente estorba.

Enlace:Vim Color Scheme Test

Ahí va otro código que desarrolle en IA. Busca la solución por el algoritmo Búsqueda profundidad del juego puzzle. El código esta hecho para Windows, y para ejecutarlo necesitas NewLisp y Mulisp que lo puedes descargar al final del post.

(define (Abajo E)
  (set 'b (find 0 E))
  (cond
   ((< (+ b 3) 9) (push (nth b E) E (+ b 3)) (pop E b)
   (push
   (pop E (+ b 3)) E b)
	(Actualiza E)))

  (print E))

  (define (Izquierda E)
  (set 'b (find 0 E))
  (cond
   ((= (= b 0) (= b 3) (= b 6) false) (push (nth b E) E (- b
      1))
    (pop E (+ b 1))
	(Actualiza E) 

	))
  (print E))

(define (Arriba E)
  (set 'b (find 0 E))
  (cond
   ((> (- b 3) 0) (push (nth b E) E (- b 3)) (pop E (+ b 1))
    (push (pop E (- b 2)) E b)
			(Actualiza E)
	))
  (print E))

  (define (Derecha E)
  (set 'b (find 0 E))
  (cond
   ((= (= b 2) (= b 5) (= b  false) (push (nth b E) E (+ b
      2))
    (pop E b)
	(Actualiza E)
	))
  (print E))

(define (Busca EI EM | Res)
  (set ‘EdosTrat ‘())
  (set ‘Res (BusAProf 1 EI EM Operadores))
  (if (not (empty? Res))
   (print Res)
   (print “\nNo hay solucion\n”)))

   (define (BusAProf Nivel EA EM Ops | ROps OpActual Encontrado NE)
  (set ‘ROps Ops)
  (set ‘Encontrado ‘())
  (setq EdosTrat (cons EA EdosTrat))
  (while (and (not Encontrado) (not (empty? Ops)))
   (setq OpActual (first Ops))
   (setq Ops (rest Ops))
   (if (setq NE (eval (list OpActual (quote EA))))
    (cond
     ((= NE EM) (set ‘Encontrado (list OpActual)))
     ((and (not (member NE EdosTrat)) (set ‘Encontrado (BusAProf
         (+ Nivel 1) NE EM ROps)))
      (set ‘Encontrado (cons OpActual Encontrado))))))Encontrado)

(set ‘Operadores ‘(Arriba Izquierda Abajo Derecha))

(define (Solucion )
    (set ‘E0 ‘())
  (set ‘EF ‘())
	  (prop-color ‘I1  254 254 254)
	  (prop-color ‘I2  254 254 254)
	  (prop-color ‘I3  254 254 254)
	  (prop-color ‘I4  254 254 254)
	  (prop-color ‘I5  254 254 254)
	  (prop-color ‘I6  254 254 254)
	  (prop-color ‘I7  254 254 254)
	  (prop-color ‘I8  254 254 254)
	  (prop-color ‘I9  254 254 254)
  (set ‘E0 (append E0 (list
	(integer (prop-text ‘I1))
     (integer (prop-text ‘I2))
     (integer (prop-text ‘I3))
     (integer (prop-text ‘I4))
     (integer (prop-text ‘I5))
     (integer (prop-text ‘I6))
     (integer (prop-text ‘I7))
     (integer (prop-text ‘I8))
     (integer (prop-text ‘I9)))))
		(set ‘cero (+ (find 0 E0) 1))
		(eval-string (string (concat “(prop-color ‘I” (string cero) ” 200 200 200)”)))
  (set ‘EF (append EF (list
	(integer  (prop-text ‘F1))
	 (integer (prop-text ‘F2))
     (integer (prop-text ‘F3))
     (integer (prop-text ‘F4))
     (integer (prop-text ‘F5))
     (integer (prop-text ‘F6))
     (integer (prop-text ‘F7))
     (integer (prop-text ‘F8))
     (integer (prop-text ‘F9)))))
  (prop-text ‘S (string (Busca E0 EF))))
(define (Actualiza E)
  (set ‘cero (+ (find 0 E) 1))
  (sleep 900)
	(prop-text ‘I1 (string (nth 0 E)))
   (prop-text ‘I2 (string (nth 1 E)))
   (prop-text ‘I3 (string (nth 2 E)))
   (prop-text ‘I4 (string (nth 3 E)))
   (prop-text ‘I5 (string (nth 4 E)))
   (prop-text ‘I6 (string (nth 5 E)))
   (prop-text ‘I7 (string (nth 6 E)))
   (prop-text ‘I8 (string (nth 7 E)))
   (prop-text ‘I9 (string (nth 8 E)))
   (eval-string (string (concat “(prop-color ‘I” (string cero) ” 200 200 200)”)))
)

(define (inicio )
  (text-font “Arial” -14 0)
  (win-dialog ‘Dialogo ‘console 150 150 520 300 “Tarea 2 ::: Puzzle”)
  (win-label ‘Texto1 ‘Dialogo 50 20 150 22 “ESTADO INICIAL”)
  (win-label ‘Texto2 ‘Dialogo 240 20 150 22 “ESTADO FINAL”)
  (win-editline ‘I1 ‘Dialogo 60 50 20 20 “1″)
  (win-editline ‘I2 ‘Dialogo 95 50 20 20 “1″)
  (win-editline ‘I3 ‘Dialogo 130 50 20 20 “1″)
  (win-editline ‘I4 ‘Dialogo 60 80 20 20 “1″)
  (win-editline ‘I5 ‘Dialogo 95 80 20 20 “1″)
  (win-editline ‘I6 ‘Dialogo 130 80 20 20 “1″)
  (win-editline ‘I7 ‘Dialogo 60 110 20 20 “1″)
  (win-editline ‘I8 ‘Dialogo 95 110 20 20 “1″)
  (win-editline ‘I9 ‘Dialogo 130 110 20 20 “0″)
  (win-editline ‘F1 ‘Dialogo 240 50 20 20 “1″)
  (win-editline ‘F2 ‘Dialogo 275 50 20 20 “1″)
  (win-editline ‘F3 ‘Dialogo 310 50 20 20 “1″)
  (win-editline ‘F4 ‘Dialogo 240 80 20 20 “1″)
  (win-editline ‘F5 ‘Dialogo 275 80 20 20 “0″)
  (win-editline ‘F6 ‘Dialogo 310 80 20 20 “1″)
  (win-editline ‘F7 ‘Dialogo 240 110 20 20 “1″)
  (win-editline ‘F8 ‘Dialogo 275 110 20 20 “1″)
  (win-editline ‘F9 ‘Dialogo 310 110 20 20 “1″)
  (win-editline ‘S ‘Dialogo 40 170 400 22 “”)
  (win-label ‘Texto3 ‘Dialogo 40 150 150 22 “SOLUCION:”)
  (win-pushbutton ‘Solucion ‘Dialogo 370 50 70 22 “Solución”
   ‘Solucion)
  (prop-enabled ‘Aplicar 0))

(define-macro (local var-list)
  ((append ‘(lambda ) (list var-list) (rest (args local)))))

(define (opsys )
  (cond
   ((primitive? clear-console) ‘windows)
   ((primitive? int86)
    (if (primitive? comm-read)
     ‘dos ‘extender))
   ((primitive? registry-read) ‘win32)
   (true ‘unix)))

(define-macro (setq p1 p2)
  (set p1 (eval p2)))

Aquí es cuando te das cuenta de que la Inteligencia es de buscar… no de pensar(¿O buscar es pensar?).
Descargar newlisp.zip
Ver código en pastebin.com.

Hace unos días vi que los cabrones de #textmotion andaban comentando sobre este evento que se realizara en la Ciudad de México el día 23 de junio, se me había olvidado apuntarme, pero gracias a pablasso me acorde.

Pues ya lo hice, no se que criterios tomen para que te inviten. Pero espero que sea un afortunado, por esas fechas estaré (espero) desocupado de la(maldita) escuela. Seria una buena oportunidad para conocer a muchos cabrones como el amargado maop, el h1pp1e , el gnuget.

El Developer Day de Google 2008, se enfocará en promover la apertura de las fronteras de las aplicaciones Web, empleando las tecnologías de desarrollo de Google. Los ingenieros de Google y desarrolladores líderes serán tus anfitriones en un día completo de profundas sesiones sobre las últimas tecnologías de Google.

El Developer Day de Google 2008, es también un foro para convivir y compartir tus ideas con otros desarrolladores. Contarás con tiempo suficiente para conversar y conocerlos, discutir tus ideas y compartir tus proyectos.

Por cierto pregúntenle al xiam por que no va a ir.

Link: http://code.google.com/intl/es_mx/events/developerday/2008/about.html

Actualización: Ya confirmaron mi invitación al evento, nos vemos por esas fechas a quién vaya a ir. Si vas, deja tu mensaje para ponernos de acuerdo.

Un truco interesante para emular las excepciones de java en php.

set_error_handler(’error_handler’);
function error_handler($errno, $errstr, $errfile, $errline) {
if (4096 == $errno) throw new Exception($errstr);
return false;
}

Y después:

try {
// Operación que produce error
} catch (ErrorException $e) {
// Tratar el error
}

Si alguno de ustedes lectores conocen algo de programación, este código les provocará una sonrisa y quizás una carcajada.

<sarcasmo>Lo mas sorprendente es que le podemos criticar todo a Windows Vista… pero no podemos negar que tienen muy buenos programadores. !Que código mas óptimo¡, rehúsan codigo y la POO correctamente aplicada</sarcasmo>

Visto en puntogeek.com

Digo esto por que el usar un framework para programar un proyecto, donde las cosas básicas están programadas y solo es de utilizarlas, aun así nuestro código no tiene nada de bueno.

Algunas veces por que no conocemos toda la herramienta tendemos hacer un código mal hecho, usando cosas que no se deberían de usar, o la usamos de un modo incorrecto.

Me dí cuenta cuando leí el articulo de Pablasso: Utilizando Prototype correctamente que tendemos a usar incorrectamente un framework por dos razones.

• No tener tiempo de leer la documentación: Y usamos lo primero que encontramos, pues nos funciona y ya ¿Para que queremos mas?
• No conocer el lenguaje: Es lo malo de los frameworks, aveces su facilidad nos impide conocer el lenguaje a profundidad y hacer mejor las cosas.

Me incluyo en los malos programadores, solo como recomendación creo que hay que leer la documentación de la pagina oficial del proyecto. A veces por flojera se busca en Internet y se llega a sitios que están igual de desinformados que nosotros y nos heredan los malos consejos.

Ya he hablado sobre algunas alternativas para evitar a la gente indeseable en los sítios de Internet. Leyendo sentidoweb me entero de este captcha que para validar que no eres bot, te pide que corrijas un código en javascript con errores.

La idea es creativa, pero no deja de ser simplemente didáctica. Así que para mi no es una buena idea, quizás para otra personas sí.

Codetcha

Pues como prometí postear todo código que programara en IA, les dejo el primero. Sirve para convertir de inorden a preorden.

)


Lisp es un lenguaje muy loco, cuesta un poco agarrarle la onda. Ya que uno piensa en un problema y ya sabe como resolverlo de manera estructurada, pero con Lisp es otro paradigma.

Por si no sabían, VIM tiene un diff entre archivos tan solo con teclear en consola.


vim -d file1 file2

Y te saldrá la pantalla dividida (tipo split) con las diferencias entre archivos.

Un truco muy bueno, que al menos yo no conocía.

return Recursividad;

Esta semana ha sido mis primeros y verdaderos contactos con Inteligencia Artificial y al menos desde el punto de vista del profesor, los códigos son muy pequeños… pero eso sí, muy bien pensados y hechos en Lisp los reducen aún más.
Lisp es un lenguaje que rompe paradigmas a como estamos acostumbrados a programar, los que lo conozcan me darán la razón.
Es interesante ver en Lisp que todo se programa en base a listas y funciones, por ejemplo el factorial se programaría así.
(defun factorial (n)
(cond
((eq n 1 ) 1 )
(t (* n ( factorial (- n 1 ))))
)
)

Desde un intérprete muy al estilo python.
Ya empezamos a ver los primeros algoritmos, como reconocimiento de patrones. Como les mencione en un anterior post, prometo postear todo código que me dejen de tarea.

Hace tiempo en los foros de ubuntu, algunos se aprovechaban de la inocencia de las personas y ponían códigos maliciosos que estropeaban su sistema. Y la gente pensando que era otra cosa los ejecutaba.

Bueno… alguien hizo un video de la muerte de ubuntu ejecutando.

sudo rm -rf /

http://www.youtube.com/watch?v=D4fzInlyYQo

Y ver que es lo que pasa….