Distribución de teclado

Arranquemos la historia a principios de siglo, porque en algún momento hay que arrancarla.

Mi computadora principal hogareña tenía un teclado con distribución "en español" (lo que normalmente se consigue en las casas de computación), pero en el laburo que arranqué en el 2000 (Unifón) todas las computadoras tenían distribución "latinoamericana" (que es lo que venden las marcas grandes, como IBM, Dell, etc, en toda Latinoamérica).

Los teclados eran diferentes, sí, pero no tanto. Encima alrededor del 2004 decidí comprarme un teclado de buena calidad, y elegí uno marca IBM, como los de la oficina, que me gustaban mucho. Obviamente, era distribución latinoamericana.

Desde ese momento usé esa distribución exclusivamente.

La laptop que usaba los últimos meses de Movistar, la que me dieron en Cyclelogic (una Dell Inspiron), y la que me dieron en Ericsson (creo que una HP) todas eran compradas acá así que eran todas con teclado latinoamericano.

Cuando entré en Canonical, me compré una laptop yo. En ese momento compré en Argentina una Dell XPS m1330, muy linda máquina. Al momento de renovarla busqué mucho y terminé en una Samsung que nunca me convenció mucho, también comprada acá. En ambos casos, teclado latinoamericano.

Y mientras tanto, seguía usando en la desktop el excelente teclado IBM que me había comprado hace tanto tiempo.

El año pasado volvía a renovar la laptop, y luego de buscar varios meses algo que me convenciera acá en Argentina, en Chile o en Uruguay, terminé tomando la decisión de comprarla en USA (una Lenovo Thinkpad). Claro, con teclado en inglés, pero mi idea era luego comprar el teclado acá y cambiárselo.

Muchas personas (desde hace mucho tiempo) me preguntaban por qué no usaba teclado en inglés y listo. Puedo agrupar toda esa gente en dos grandes grupos:

  • los que usan el teclado en inglés configurado como "inglés", sin acentos ni eñe, pero escriben todo el tiempo con faltas de ortografía; esto es llanamente inaceptable para mí.
  • los que usan el teclado en inglés configurado como "internacional con teclas muertas" (que era como yo tenía la laptop nueva), donde para poner un acento hay que teclear el tilde y luego la vocal; el problema de esto es que para escribir el tilde sólo, hay que teclear el tilde y luego espacio (y como es la misma tecla, para comillas hay que hacer shift+tilde y luego espacio). Funciona, pero es tremendamente ineficiente y molesto.

El 2017 me encontró con el mismatch de teclado entre el desktop y la laptop, algo que me molestaba bastante. Y en Agosto pasaron dos cosas.

Por un lado ya me había cansado de esperar que Lenovo Argentina me vendiera un teclado en latinoamericano para la laptop. Nunca lo importaron, siempre me lo patearon para adelante, ¡durante un año!

Por otro lado, Joac me mostró que hay una configuración "internacional con teclas muertas por AltGr", que lo que hace es evitar el "doble tecleo": para poner una á, sólo hay que hacer AltGr+a. Y listo. Tilde es tilde, comilla es comilla, etc. Hay casos donde necesitamos componer caracteres con varias teclas, pero no es frecuente (por ejemplo, si queremos escribir una ü, donde ahí si tenemos que teclear AltGr+shift+tilde, y luego la u).

Esta configuración me resultó bastante funcional (aunque no ideal), así que lo que tenía que hacer también era solucionar el mismatch con la desktop, por lo que me compré en el último viaje un teclado Lenovo que es igualito al IBM que tenía... pero en inglés.

Así que acá me ven, a la vejez viruela, etc, etc.

Comentarios Imprimir

Usando Go desde Python

¿Alguna vez necesitaron usar un código de Go desde Python? Yo sí, y acá cuento qué hice.

Antes que nada, un poco de background, para que el ejercicio no sea demasiado teórico: en el laburo tenemos que validar las licencias que se incluyen en el .snap, y aunque el formato en que están sería estándar (SPDX), una condición de contorno es usar el mismo parser/validador que se usa en snapd, para estar 107% seguros que el comportamiento va a ser el mismo hasta en los corner cases o bugs.

El detalle es que snapd está escrito en Go, y el server está escrito en Python. Entonces tengo que compilar ese código en Go y usarlo desde Python... de allí este post, claro.

Es más fácil de lo que parece, ya que el compilador de Go tiene la capacidad de buildear a "biblioteca compartida", y de ahí usarlo desde Python es casi trivial ("casi", porque tenemos que poner algo de código en C).

Para ser más claro, si queremos ejecutar "la lib de SPDX hecha en Go" desde nuestro Python, tenemos que poner dos componentes, que funcionan casi de adaptadores:

  • Un pequeño código en C para armar "como módulo" una funcioncita que recibe y entrega objetos Python, y hace la traducción al "mundo C" y llama a otra función en Go.
  • Un pequeño código en Go que traduce los parámetros desde C y llama a la biblioteca SPDX correspondiente.

Adaptador de Python a C

El archivo completo es spdx.c, paso a explicarlo haciendo antes la aclaración que es para Python 2 (que es lo que tenemos hoy en ese servicio), pero si fuera para Python 3 sería muy parecido (la idea es la misma, cambian algunos nombres, revisen acá).

Antes que nada, incluir la lib de Python:

#include <Python.h>

Vamos a llamar a una función de Go, necesitamos explicitar lo que va recibir (una cadena de bytes, que a nivel de C es un puntero a chars) y lo que nos devuelve (un número, que interpretaremos como bool):

long IsValid(char *);

Definimos la función que vamos a llamar desde Python... es sencilla porque es genérica, recibe self y argumentos, devuelve un objeto Python:

static PyObject *
is_valid(PyObject *self, PyObject *args)

El cuerpo de la función es sencillo también. Primero definimos 'source' (el string con la licencia a validar) y 'res' (el resultado), luego llamamos a PyArg_ParseTuple que nos va a parsear 'args', buscando una cadena ('s') la cual va a poner en 'source' (y si algo sale mal nos vamos enseguida, para eso está el 'if' alrededor):

{
    char * source;
    long res;

    if (!PyArg_ParseTuple(args, "s", &source))
        return NULL;

Finalmente llamamos a IsValid (la función en Go), y a ese resultado lo convertimos en un objeto de Python tipo bool, que es lo que realmente devolvemos:

    res = IsValid(source);
    return PyBool_FromLong(res);
}

Ahora que tenemos nuestra función útil, debemos meterla en un módulo, para lo cual tenemos que definir qué cosas van a haber en dicho módulo. Entonces, armamos la siguiente estructura, con dos lineas; la primera habla sobre nuestra función, la última es una marca en la estructura para que sepa que es el final:

static PyMethodDef SPDXMethods[] = {
    {"is_valid", is_valid, METH_VARARGS, "Check if the given license is valid."},
    {NULL, NULL, 0, NULL}
};

En la linea útil tenemos:

  • "is_valid": es el nombre de la función que vamos a usar desde afuera del módulo
  • is_valid: es una referencia a la función que tenemos definida arriba (para que sepa qué ejecutar cuando llamamos a "is_valid" desde afuera del módulo.
  • METH_VARARGS: la forma en que recibe los argumentos (fuertemente atado a como luego los parseamos con PyArg_ParseTuple arriba.
  • "Check ...": el docstring de la función.

Para terminar con este código, va el inicializador del módulo, con un nombre predeterminado ("init" + nombre del módulo), y la inicialización propiamente dicha, pasando el nombre del módulo y la estructura que acabamos de definir arriba:

PyMODINIT_FUNC
initspdx(void)
{
    (void) Py_InitModule("spdx", SPDXMethods);
}

Adaptador de C a Go

El archivo completo es spdxlib.go.

Tenemos que meter el código en un paquete 'main':

package main

Importamos el código para SPDX de snapd (tienen que bajarlo antes con go get github.com/snapcore/snapd/spdx):

import "github.com/snapcore/snapd/spdx"

Importamos adaptadores desde/a C, indicando que cuando buildeemos vamos a usarlo desde Python 2:

// #cgo pkg-config: python2
import "C"

La función propiamente dicha, donde indicamos que recibimos un puntero a char de C y vamos a devolver un bool:

//export IsValid
func IsValid(license *C.char) bool {

El cuerpo es nuevamente sencillo: llamamos al ValidateLicense de SPDX (convirtiendo primero la cadena a Go), y luego comparamos el resultado para saber si la licencia es válida o no:

    res := spdx.ValidateLicense(C.GoString(license))
    if res == nil {
        return true
    } else {
        return false
    }
}

Cerramos con la definición obligatoria de main:

func main() {}

Lo usamos

Primer paso, buildear (yo tengo Go 1.6, creo que necesitan 1.5 o superior para poder armar directamente la biblioteca compartida de C, pero no estoy seguro):

go build -buildmode=c-shared -o spdx.so

Segundo paso, profit!

$ python2
>>> import spdx
>>> spdx.is_valid("GPL-3.0")
True
Comentarios Imprimir

Trabajando en New York

Toda la semana pasada estuve también de viaje, aunque no de placer, sino de trabajo. De sprint, bah, como tantas otras veces.

Esta vez tocó New York, una ciudad bastante grande y conocida, pero a la que yo no había ido nunca. Así y todo de ciudad cosmopolita y una de las más "importantes" del mundo (atenti a las comillas) yo no tenía demasiada expectativas con el viaje.

Es que, como dije antes, era por laburo. Entonces uno no se arma de lugares para visitar y pasear, ya que no hay demasiado tiempo, normalmente. En este caso tuve la suerte que el horario de laburo fue 8:30-17:30, y sumado a que recién arrancaba el otoño, había luz bastante rato al salir cada día, entonces pude pasear más de lo que preví.

Restringido a adultosViejo taxiMuchos carriles en el subte

Como me gusta a mí, estuve caminando un montón. Yendo de un lado para el otro, mirando la gente, etc. El domingo que llegué, ahí nomás, estuve caminando una hora sólo para llegar al restaurant donde íbamos a almorzar con Naty, Matias, y una pareja amiga de ellos.

Por otro lado, no me moví demasiaaaaaado de donde estaba el hotel. O sea, algunos kilómetros para acá, algunos kilómetros para acá, pero (casi) no salí de la isla de Manhattan, que es como la parte más monona de Nueva York.

Esquina típicaEstación Central

Mis primeras impresiones fueron... digitales. No, digo; mis primeras impresiones fue que había demasiada gente y demasiado ruido. Después me di cuenta que la ciudad huele feo, por todos lados, todo el tiempo. Y es cara, y hay poca luz.

En otras palabras, no me gustó New York. No todo es malo, eh. Tiene un parque fantástico (ver abajo), una vida cultural buenísima, la comida es decente (lo cual es bastante, para ser Estados Unidos), buenos bares, y un par de detalles más, pero en general, es una ciudad que no disfruté como otras.

Todo esto no evitó que pasee y conozca.

Contraste entre dos edificios

Una de las tardes me fui a caminar un rato por Chinatown (el barrio chino, bah... me quedo con los de Londres y Buenos Aires), que está pegado a una zona llamada "Little Italy" (Pequeña Italia), que tiene una interesante variedades de lugares para comer italiano. No me quedé por esa zona, porque mi idea era cenar en un local clásico de Nueva York: Katz.

Aunque es un restaurant famoso por ser sede de escenas de varias películas (la más famosa quizás fue el escandaloso orgasmo fingido por Meg Ryan en Cuando Harry conoció a Sally), mi intención era ir allí porque es uno de los mejores lugares para comer pastrami.

Barrio ChinoPastrameeeeeeeeeeeee

No me volvió loco, el pastrami. Si lo tengo que describir, piensen en una tapa de asado ahumada y cocinada muy lento, tanto que se deshace completamente, con un sabor que parece un embutido rico. Fue algo totalmente nuevo para mí, a nivel comida: objetivo cumplido.

Algo que sí me gustó bastante fue el Central Park. Un espacio verde enorme, ahí en el medio de la ciudad, de los rascacielos y las avenidas. Como los bosques de Palermo, podrán pensar... bueno, como para ponerlo en perspectiva, el Central Park es OCHO veces más grande que los bosques de Palermo.

El viernes cortamos el laburo a la 4, y yo aproveché el extra de luz y me fui para el parquecito. Llegué rápido (estaba a unas 10 o 15 cuadras) y estuve caminando hasta que se hizo de noche. Lo crucé a lo ancho, y no llegué ni a la mitad longitudinalmente hablando, pero todo lo que ví me gustó: un bosque, básicamente, con senderotes, senderos y senderitos, iluminado y cuidado.

Parque CentralBiblioteca de New York

El sábado tenía varias horas para pasear. Con Ricardo y Maxi nos tomamos un subte hasta el sur de Manhattan, y de ahí un ferry hasta la isla de enfrente, un paseito corto y piola para sacarle unas fotos a la Estatua de la Libertad. Cuando volvimos pegamos una vuelta por la parte financiera (Wall Street y eso), nos acercamos hasta el puente de Brooklyn (el cual empezamos a caminar, pero no cruzamos), y luego enfilamos para pegar un par de vueltas al Barrio Chino y a la Little Italy, donde merendamos en un café muy bueno (yo probé un capuchino y un cannolo a la siciliana, impecables).

En tu cara, toroManhattan, desde el ferry

Después no mucho más. Subte de vuelta al hotel, agarrar las valijas, juntarnos un grupito e ir a la parada del NYC Airporter, el micro que nos llevó al aeropuerto, checkin, espera, viaaaaaaje, y casita :).

Todas las fotos, acá.

Comentarios Imprimir