• Características del sistema mkx86 
• Compilando mkx86 en Ubuntu amd64 (x86_64) 

Este es un script que utilizo para ayudarme en la documentación de código php. Con un simple Control+P inserta los valores más comunes en la clase, función o variable.

phpDocumentor for vim

Vaya que es necesario tener código bien documentado, así los demás puedan seguir la evolución del código. ¿Ya dije que uso vim?

¿creen que vim es para masoquistas? Pues no, tiene todo lo necesario para lo que necesito: syntax highlighter, code snippets, autocomplete, search/replace, record actions, class browser, window split, etc. Y más todavía con los scripts disponibles en vim.org

A mi amigo le invitaron a entrar a Escas y a MKS, ellos son tranquilos, sólo pelean.

He entrado porque es mejor estar de su lado, que contra ellos. La pandilla me da protección....

Mi hijo está en una escuela donde predomina el inglés y se venía solo.... Lo peor es que estos pandilleros son hijos de familias adineradas, no sé qué está pasando en Cochabamba, pero estoy asustada. Ahora vamos a recoger a mi hijo.

Yo creo que lo malo esta en que somos una sociedad que es buenísima para hacerse la vista gorda. Ejemplos: maltrato infantil, violencia de género, familias disfuncionales, etc. Cosas que se sabemos que esta mal, pero que las toleramos.

Nos conformamos con tener nuestro carnaval, nuestro primer viernes, nuestro misa chico, nuestro bautizo, fiestita del santo, fiesta del barrio, etc.

No digo que este mal la diversión ni esparcimiento, sino que siempre se prefiere el cuetillo a otras cosas más importantes. Si hay paro, crisis nacional... pero llega una fiesta "grande", entonces cuarto intermedio.  

Yo creo que parte mucho de los padres, pero muchas veces no se puede juzgar.

Quiero contar mi levemente mi caso, yo vengo de padres separados desde que era bebe. He vivido con ambos varios años, en Santa Cruz, Tarija, Sucre, Beni, Cochabamba, Potosi.

Estudie dos años en potosi, y el primer año conoci a chicos que no eran tan buenas influencias -aunque siempre he sido un cachón y rebelde-, pero estaban involucrados con "grupos" así, hasta quería empezar uno... eran de: "¿te quieres dar? Ok, vos treas a tus cuates, yo a mis cuates, y así nos damos". Un tiempo un cuate tenía una "mariposa" -esa navaja de tres-, y "practicabamos" eso de hacerle girar en una mano y etc.

Luego en cochabamba, cerca nuestro colegio había un billar, y lo frecuentabamos a la salida, o en las chachadas. Se conocía harta gente, pero tambien algunos involucrados en "esos grupos". Eran chicos con plata, con auto ya (hace unos 8 años). Y si, una parte tenía sus padres en el norte y tambien algunso se habían criado allá. Entre fiestas, salidas, farras, una y otra cosa uno se va involucrando sin querer...

Como el año pasado, sali con los cuates de un cuate de cole, uno de ellos había venido del norte con sus viejos, estaba aca, era de dinero tener, de brocas tener, de tener cuates "conocidos" en el ambiente. Siempre en peleas, mano rota, broncas, etc.

Pero lo último que supe es que se suicido... 

Lo que quiero explicar, es que una persona si no encuentra el espacio para desarrollarse de buena manera, ni recibe orientación, no es difícil caer en malos rumbos.

No es tan fácil decir: "esos changos son malos, son menos, son una lacra, por qué no se dedican a mejores cosas". 

Todos ellos son producto de la sociedad, nuestra sociedad.

Sinceramente no creo que una sociedad pueda cambiar, a menos que haya un evento extraordinario como una guerra similar a japón o alemania.

Mientras tanto, podemos atenuar nuestro entorno enseñando con el ejemplo, que al final son influencias.

Ultimamente estoy usando Zend (framework php), yo ya más acostumbrado a django estaba buscando algo como

      count = Comment.objects.filter(owner=1).count()     

Pero en Zend la opción que encontre fue:

      $table = new Comments;       $select = $table->select()->where('owner = ?', 1);       $comments =  $table->fetchAll($select);       $count = $comments->count();   ...tedioso!!!   e ineficiente, por que primero saca todos los resultados de la db, y   recién retorna la cantidad. En cambio todos sabemos que un SELECT   COUNT(*) es mucho más rápido, especialmente con tablas indexadas.   Entonces,   todos mis modelos heredan de Core_Db_Table que esta a su vez hereda de   Zend_Db_Table, añado un método para realizar mi querido SELECT COUNT(*)   [code=php]          class Core_Db_Table extends Zend_Db_Table {          // ...           public function count(Zend_Db_Select $select) {              $select = $select->from($this->info("name"), array("count" => "COUNT(*)"));              return $this->getAdapter()->fetchOne($select->__toString());           }       }     

 Listo, ahora ya puedo hacer cosas más decentes:

      $table = new Comments;       $select = $table->select()->where("owner = ?", 1);       $count = $table->count($select);     

No es tan hermoso como django.... pero algo es algo . De ahí es un paso para permitir $table->count()  o $table->count("owner = ?", 1)

Autor: Vesmar Camara

Info:  http://softwarelibre.org.bo/mkx86/

== Introducción ==

El sistema mkx86 es el "Microkernel para la arquitectura x86".

Es una implementación académica que ejemplifica los conceptos de
diseño de microkernels como núcleos de SO.

Bueno, resumiendo... es un sistema operativo que viene desarrollandose
desde el 2001 y finalmente se hace publico.

Nota: http://softwarelibre.org.bo/vesmar/weblog/1884.html
Descarga: http://sourceforge.net/projects/mkx86

¿escucharon ese chiste?

"Si camina como pato, hae quack como pato... es un pato"

Se refiere al famoso Duck Typing, según la wikipedia:

In computer programming, duck typing is a style of dynamic typing in which an object's current set of methods and properties determines the valid semantics, rather than its inheritance from a particular class. 

Hace años que lo leí la primera vez... pero recién lo entendí hace unas semanas en una presentación de Ernesto, dondé simplemente repitió lo mismo -más o menos palabras-.

Siempre me pareció chistoso el duck typing, pero ahora que lo entendió me da más risa

Practicamente es suficiente añadir los métodos necesarios a una clase/objeto para que soporte cierto comportamiento. En python todo puede parecer un pato... seguramente en cualquier lenguaje dinámico

Por ejemplo, la método para order algún lugar

  def ordenar(lugar):       """       Mi algoritmo para order cosas       """       print '[+] ordenando %s' % lugar       for cosa in lugar:  # lugar puede ser una lista           print 'encontrado: %s' % cosa           if cosa.sirve:               if cosa.esta_sucio:                   print '\tlimpiando: %s' % cosa                   limpiar(cosa)               if cosa.es_importante:                   if cosa.tiene_lugar:                       print '\tponiendo en su lugar: %s' % cosa                       poner_en_su_lugar(cosa)                   else:                       print '\tguardando: %s' % cosa                       guardar(cosa)               else:                   print '\ta algún rincón: %s' % cosa                   poner_en_un_rincon(cosa)           else:               print '\tal basurero:', cosa               al_basurero(cosa)    

luego tengo objetos que pueden estar en algun lugar:

 
class MiLibro(Libro):
 
    titulo = 'Duck Typing Redux'
 
    autor = 'Rho'
 
    # tambien puedo ser cadena
 
    def __str__(self):
 
        return 'Libro "%s"' % self.titulo
 
class Donald(Pato):
 
    nombre = 'Donald'
 
    def __str__(self):
 
        return 'Pato Donald'
 
class Rho(Persona):
 
    nombre = 'Rolando'
 
    # print yo
 
    def __str__(self):
 
        return '%s' % self.nombre
 
  

Ahora podemos tener nuestros objetos:

  libro = MiLibro()   pato = Donald()   rho = Rho()     

Pero ninguno es una "cosa" ordenable, según los métodos/propiedades que necesita la función ordenar.

¿qué hacemos?

Pues enseñamos a nuestros objectos a ser "ordenables", o a decir ¡cuac! 

  # enseñando a ser "pato"   libro.sirve = True   libro.esta_sucio = True   libro.es_importante = True   libro.tiene_lugar = True   # pato patito   pato.sirve = True   pato.esta_sucio = True   pato.es_importante = False   # self   rho.sirve = False     

Pero necesito un lugar que contenga las cosas, podría ser una simple lista pero quiero definir mi sala:

   class MiSala(Sala):       lugar = 'casa'       cosas = []     # lista de cosas       def __iter__(self):           # nuestra sala es "iterable" (generator rulz!)             return (cosa for cosa in self.cosas)       def __str__(self):           return 'sala en %s' % self.lugar     

Luego añado mis "cosas" a mi sala iterable..

y al final lanzo ejecuto ordenar() sobre mi sala 

  # mi sala con cosas   misala = MiSala()   misala.cosas.append(libro)   misala.cosas.append(pato)   misala.cosas.append(rho)   # ordenar todo   ordenar(misala)    

Este es el resultado:

 
rolando@rhotergeist:~$ python ducktyping.py
 
[+] ordenando sala en casa
 
encontrado: Libro "Duck Typing Redux"
 
    limpiando: Libro "Duck Typing Redux"
 
    poniendo en su lugar: Libro "Duck Typing Redux"
 
encontrado: Pato Donald
 
    limpiando: Pato Donald
 
    a algún rincón: Pato Donald
 
encontrado: Rolando
 
    al basurero: Rolando
 
 

¿fácil, no?

Moraleja: para pasar por pato sólo tienes que decir cuac y caminar como pato

¡mamá, ya entendí el chiste! 

Este es un tip que encontre hace unos días para jQuery, pero una pequeña modificación y sirve para insertar cualquier javascript mediante su url en cualquier sitio web.

• Insertar JS
• Insertar jQuery
  

Esto es más útil con firefox y la extensión firebug; con su consola javascript se puede hacer directamente prototipos rápidos sin necesidad de guardar/crear un html/js.

PD: Añadan los enlaces como marcador, o simplemente arrastrenlos a su barra de marcadores

En un principio, para crear scripts que automatizen cierto proceso escribía un script en python que empezaba por:

  from django.conf improt settings   os.environ["DJANGO_SETTINGS_MODULE"] = "proj.settings"   from app1.models import *   # ....    

Pero me entro la curiosidad por hacerlo de "mejor" manera. Entonces la opción que encontre es extender los comandos de administración (management), esos que estan disponibles mediante el script management.py:

 
rolando@rhotergeist:~/proj$ ./manage.py help
 
Type 'manage.py help <subcommand>' for help on a specific subcommand.
 
Available subcommands:
 
adminindex
 
createcachetable
 
dbshell
 
diffsettings
 
dumpdata
 
flush
 
...
 
 

A pesar de no estar documentado , no es complicado crear "nuevos comandos". Estos son los primeros pasos para crear un comando básico:

1. elegir la aplicación (app en jerga django) y nombre del comando: sayhello

2. crear el "package" adecuado de comandos dentro nuestro app

 
$ mkdir -p app/management/commands
 
$ touch app/management/__init__.py
 
$ touch app/management/commands/__init__.py
 
 

Los __init__.py son importantes para poder hacer from app.management.comands import *, sino no "reconocerá" el módulo|package.

Luego creamos el archivo de nuestro comando sayhello en app/management/commands/sayhello.py:

  # sayhello.py   from django.core.management import BaseCommand   class Command(BaseCommand):       help = "This command says hello"       def handle(self, *args, **kwds):           print "hello"    

Eso es suficiente

 
rolando@rhotergeist:~/proj$ ./manage.py sayhello
 
hello
 
 

De ahí se puede interactuar con los models, parsear información e insertar en la db, etc. python style!

Tambien xisten más clases de comandos, ej: LabelCommand, NoArgsCommand, etc. dependiendo el tipo de comando que queramos hacer.

import this

Presentada el día de ayer:

http://simonwillison.net/static/2008/xtech/ 

Javascript no-intrusivo

En pocas palabras, javascript no-intrusivo se dice al hecho de que una página no dependa de javascript para su correcto funcionamiento. En otras palabras evitar la inclusión directa código dentro los tags, por ejemplo:

  <a href="#" click="alert('hola');">Click</a>    

jQuery

jQuery es una librería javascript/ajax que facilita de manera asombrosa el uso de javascript para desarrollo web, ¡incluso haciéndolo divertido!

Ejemplo

Directo al grano, queremos añadir un botón de cerrar a los mensajes de notificación que da nuestro sitio (mensajes de error, de alerta, etc).

¿cómo lo hacemos?

Podemos hacer uso de los selectores, y en base a estos añadir funcionalidades a ciertos elementos. Por ejemplo, supongamos que queremos hacer que todos los links externos se abran en nueva ventana sin usar el atributo target -que no valida.

Con jQuery podría ser de esta manera:

  jQuery('a[@href^="http://"]').addClass('external').attr('target', '_blank');    

Primero seleccionamos todos los tags "a" con el atributo "href" que empiezan con "http://", a todos estos elementos les añadimos la clase css "external" y el atributo "target=_blank". ¿fácil, no?

Un problema de los scripts js en las página web, es que estos se ejecuten antes de que se termina la carga completa. En jQuery se utiliza lo siguiente:

  jQuery("document").ready(function() {   // instrucciones que se ejecutaran cuando el documento cargue por completo   });    

Entonces, nuestro código mágico para hacer elementos "cerrables" es....

  jQuery(function($) {   //creamos el elemento "a"   //añadimos el atributo href   // añadimos la clase css close-button   // añadimos una acción al evento "click"   // y cuando el usuario haga "click" buscamos el nodo padre con la calse "can-close" y lo hacemos "desaparecer" xD       close = $("<a>")               .text("Close")               .attr("href", "#")               .attr("class", "close-button")               .click(function() {                   $(this).parents("can-close").fadeOut(1500);               });   // a todos los elementos con la clase "can-close"   // le añadimos el botón de cerrar   $(".can-close").prepend(close);   // end    });    

En resumen, creamos el enlace para cerrar el elemento, luego buscamos todos los elementos con la clase css "can-close" y el añadimos el botón.

Mediante esta técnica, para hacer otro elemento que se pueda cerrar, simplemente le añadimos la clase "can-close".

  <div id="algo" class="can-close">Mensaje ...</div>    

Muchos proyectos web utilizan esta técnica para hacer efectos "pluggables", añaden los selectores (id/class) correctos para poder añadir comportamientos (behaviors) arbitrarios a cualquiera de ellos.

Pueden ver el demo en: jquery1.html