Sitemap
Nicolás Sanguinetti

Nicolás Sanguinetti

Geek. Developer. Gamer.

Sé Responsable

Mi charla de RubyConf Uruguay 2014, en palabras

16 min readMay 22, 2014

--

Puedes encontrar los slides de esta charla en mi página de SpeakerDeck.

Aparentemente voy a hablarles sobre responsabilidad. Los que me conocen saben que soy un irresponsable de mierda, así que no estoy muy seguro de cuánta autoridad tengo para hablar del tema.

Vamos a hablar de la responsabilidad que tenemos cada uno de nosotros al hacer nuestro trabajo como hacedores de software. La responsabilidad hacia nuestros usuarios, hacia nuestros pares, y hacia nosotros mismos.

Responsabilidad con nuestros usuarios

Esta es “fácil”. Don’t be Evil™. Es el slogan no-oficial de Google. Según ellos:

Don’t be evil. We believe strongly that in the long term, we will be better served-as shareholders and in all other ways-by a company that does good things for the world even if we forgo some short term gains.

— Larry Page, Google’s IPO Founders Letter.

“No sean malos. Creemos firmemente que a largo plazo, nos va a hacer mejor—tanto como accionistas como en cualquier otra forma—ser parte de una empresa que hace cosas buenas por el mundo, incluso si eso quiere decir dejar de lado algunos objetivos a corto plazo.”

En el caso puntual de Google el contexto es “No nos vendemos. Los resultados de búsqueda van a ser lo mejor que los podamos ofrecer, y no ofrecemos a la venta un mejor posicionamiento, ni vamos a engañar a usuarios poniendo ads en lugares donde no estén claramente identificados como tales”.

Igual a donde yo quiero ir va un poco más allá de eso. Quiero que como programadores trabajemos siempre en algo que, de alguna forma, mejore un poco el mundo. Eso no quiere decir que tienen que salir a curar el cáncer y el hambre en África—aunque si lo hacen sería genial—pero tienen que ser buena gente en cómo encaran su trabajo. Lo que hagan, tiene que ser para mejorarle la vida a los que usen sus productos, no para cagársela.

Por ejemplo, hace mucho tiempo, un foca más joven (y con bastante más pelo) trabajaba en una empresa que vendía cosas mediante SMS. Ya la premisa era medio shady. El último producto en el que trabajé ahí era un sistema que le mandabas un SMS con una canción, la buscaba (la parte técnica de hacer procesamiento de lenguaje natural para encontrar cuál era la canción dado un término de búsqueda estaba re copada), y te ofrecía un pack de 3 canciones. Si aceptabas, te mandaba la canción que habías buscado y te dejaba dos creditos a tu favor.

Cuál era la idea? No-se-qué porcentaje altísimo de los usuarios después de comprar el primer ringtone no volvían a cobrar sus dos créditos restantes, y era plata con la que se quedaba la empresa.

Cuando traté de argumentar que eso era una mierda, El Jefe me mandó a pasear, porque la “gracia” era justamente explotar la distracción de la gente. Ese día empecé a buscar otro trabajo.

¿A qué voy con esto? Como programadores tenemos una responsabilidad ética con la gente. No podemos estar haciendo algo que joda a la gente para beneficiar a un pelotudo con plata.

De nuevo, no es un “salgan a curar el SIDA ya, OR ELSE”. No, tampoco quiero que seamos todos unos hippies de mierda cantando Kumbaya alrededor de una fogata. (Ojo, de nuevo, si pueden hacer algo que haga que menos gente se enferme de SIDA, awesome!). Lo que quiero es que cuando vayan a hacer algo, lo hagan pensando en “¿Cómo mejora esto la vida de quien lo va a usar?”

Quizás es algo que le hace ahorrar 30 minutos por día de trabajo porque hace un proceso más eficiente. Eso son 30 minutos que capaz que no tiene que quedarse tarde y puede pasarlo con la gente que le importa.

Quizás es un juego que mantiene a la persona entretenida y contenta.

Quizás es una tostadora transparente que hace que veas cuándo está pronta la tostada y te enojás menos con la vida porque se te queman menos las tostadas.

No importa qué es. Lo importante es que, como programadores, tenemos que comprometernos con que lo que sea que hagamos, sea para mejorar la vida de quienes lo usan. No tiene por qué ser una mejora sustancial. Pero no puede ser para empeorar la vida de nadie.

Bajemos un poco de lo abstracto. Más allá de las intenciones de fondo que uno tenga con el software que escribe, y de la discusión ética, hay algunas cosas que podemos hacer para que el software que hacemos sea el mejor que podemos hacer.

Fácil y Simple

Es importante que el servicio que brindemos sea comprensible. Cualquier herramienta que no lo sea, estamos condenando a nuestros usuarios a pasar mal tratando de usarla.

¿Cómo definimos “simple”? El origen de la palabra viene del latín, “sem-plex”, que quiere decir “un pliegue” / “una hebra”.

Esto es, “una parte”. Algo simple es algo que no tiene muchas partes. Algo que podemos comprender rápidamente porque no cuesta visualizarlo en su totalidad.

Esto es distinto de algo “fácil”. Algo fácil es algo que nos resulta familiar, algo que podemos comprender porque estamos acostumbrados a ello.

Simple es una medida absoluta, fácil es relativo a la persona.

Les recomiendo ver la charla “Simple Made Easy” de Rich Hickey, que aborda este tema en mucho mayor detalle, y es una de las mejores
charlas de ingeniería de software que he visto.

Interfaz

En el contexto de responsabilidad hacia nuestros usuarios, hablemos de la interfaz. Yo se que la mayoría acá somos programadores y no diseñadores, pero es muy importante aprender algunas cosas de diseño de UI para evitar papelones y hacer algo que el usuario no sufra usando.

Queremos que la interfaz sea simple y se sienta fácil. O sea, que no tenga demasiadas cosas a la vez, pero además, que las que tenga se sientan familiares para nuestros usuarios.

Lamentablemente la mayoría de nosotros somos programadores, no diseñadores, y los programadores somos notoriamente malos diseñando interfaces. ¿Cómo podemos, entonces, ser responsables hacia nuestros usuarios y brindarles una interfaz fácil y simple?

Podríamos hablar durante horas de esto, y lamentablemente no nos da el tiempo, pero por suerte otra gente ha hecho el trabajo duro y ha dado buenas charlas al respecto. Un par que podrían mirar son:

Lo importante es que aprender un poco de algunas cosas de diseño nos da una buena base para hacerle la vida a los usuarios más placentera. Sin embargo, no hay que pretender saber TODO lo que hay para saber de diseño. Incluso aprendiendo técnicas básicas, no vamos a crear interfaces maravillosas siempre. ¿Cómo hacemos, entonces?

¡Molesten a un diseñador! No muerden, lo prometo. Pídan ayuda. Trabajen con alguno. ¡Es su responsabilidad molestar un diseñador! No tienen que saber todo de todo. Es mejor conseguir ayuda de otros y complementarse.

Performance

Esto es parte del Zen of GitHub, una serie de máximas sobre cómo escribir software con la “filosofía” de GitHub:

It’s not fully shipped until it’s fast.
Responsive is better than fast.

A qué viene esto? Nuestra responsabilidad es entregar software que funciona bien. Algo que funciona lento no funciona. Punto.

Pero más allá de que algo sea rápido, lo importante es que se perciba como rápido. Esto es, no importa si algo demora 5 segundos en cargar, si la UI nunca demora más de unos pocos milisegundos en refrescarse y mostrar cambios en el estado.

Un claro ejemplo de esto es por qué haciendo aplicaciones web ponemos los javascripts al final del documento y no en el <head>. Cuando los browsers evalúan javascript entran en single threaded mode, por lo que evaluar un JS requiere que el browser deje de cargar el HTML, el CSS, y renderizar el markup en pantalla. Si de repente tiene que evaluar 200 Kb de javascript que se encuentran en el <head> (el cuál se evalúa antes de que se empiece a mostrar contenido), quiere decir que va a tener que pausar por 50–100 ms en los cuales el usuario va a ver una página en blanco sin nada y sin actividad.

El tiempo total de carga es el mismo. Pero poniendo los JS al final el usuario no percibe la demora inducida por evaluar el JS.

Una vista demora mucho en generarse? Carguen una versión inicial con un spinner y hagan push del contenido al cliente (o hagan polling si no pueden usar push), y muestren el contenido a medida que lo tengan disponible.

Lo importante es que el usuario nunca puede quedarse esperando en un lugar donde no puede interactuar con sus alrededores.

Ojo! La performance es quizás el trait más importante en el software que producimos (después de que funcione como debe, claro), pero esto no quiere decir que haya que salir a optimizar cada línea de código. Knuth nos dice, en su paper Structured Programming with Go To Statements:

Premature optimization is the root of all evil.

“La optimización prematura es la raíz de todos los males.”

El código tiene que ser mantenible y entendible. Cambiar todas las divisiones a bitwise operations porque ahorra ciclos de CPU no otorga una mejora medible en general (salvo, quizás, que estén trabajando en embedded appliances o en un marcapasos o algo así—pero por favor, no usen ruby en un marcapasos).

Ante la duda, las únicas mejoras de performance que importan son las que el usuario va a percibir. Cualquier cosa que no sea medible, no necesita ser optimizada.

Responsabilidad con nuestros pares

Bueno, hablemos un poco de la responsabilidad hacia nuestros compañeros. En mi primer trabajo programando, un amigo me dijo la máxima de vida más útil relativa a la programación que escuché:

Tenés que programar como si la persona que vaya a mantener tu código en seis meses es un psicópata homicida que sabe dónde vivís.

Lo que queremos, entonces, para evitar psicópatas asesinos, es que nuestro código sea fácil de mantener.

Mantenibilidad

El concepto de “mantenibilidad” es un poco difuso, quizás, así que tratemos de acotarlo un poco. Vamos a decir que código mantenible es código:

  • Legible
  • Claro
  • Comprensible
  • Modificable

Claridad y Prolijidad

Nuestro trabajo involucra mucho más lectura de código que escritura de código. El código que Uds. escriben hoy lo van a leer Uds. mañana, sus compañeros pasado mañana, y otros psicópatas homicidas en seis meses.

Es importante que el código sea legible. Es importante que el código esté bien indentado, y que siga las normas de estilo de tu empresa o comunidad.

Get Nicolás Sanguinetti’s stories in your inbox

Join Medium for free to get updates from this writer.

Para que el código sea claro, además, tiene que ser directo. Tiene que ser sucinto y terso, para reducir las distracciones al leerlo.

10.times { puts "hi" }

vs

i = 0
while i < 10
puts "hi"
i += 1
end

El primer snippet es inmediatamente comprensible por dos motivos:

  1. Menos código—volvemos a la simpleza. El código más simple, al tener menos partes, se puede comprender más rápido.
  2. Está más cerca del lenguaje natural con el que expresamos nuestras ideas. Uno naturalmente diría “Quiero decir esta palabra 10 veces”. Uno nunca diría “Quiero tener cero dedos levantados, e ir levantándolos de a uno; y por cada vez que levanto uno, decir esta palabra, hasta que tenga 10 dedos levantados y ahí callarme la boca”. Al estar más cercano al lenguaje con el que nos expresamos, es más fácil para nosotros.

Ruby es un excelente lenguaje para escribir código que se acerque bastante al lenguaje natural, es un lenguaje que nos permite ser tersos y sucintos. Y que nos permite escribir código que se lee casi como lenguaje natural.

Podemos, también, escribir código para generarnos un metalenguaje arriba de ruby que se lea tal cual como lenguaje natural. A mucha gente le encanta hacer estas cosas (ahem RSpec ahem).

¡Ojo! El que podamos hacer algo no quiere decir que debamos. Cuando decidamos escribir algo de código “mágico”, preguntémonos “¿Debo?”. La respuesta es casi siempre un rotundo “No”.

¿Por qué? El código “mágico” es en general mucho más complicado de mantener. Hay que encontrar un balance entre legibilidad y cercanía al lenguaje natural, considerando siempre con mucho cuidado las decisiones que tomamos que puedan afectar la mantenibilidad del código.

Si bien el primer snippet es inmediatamente más comprensible, internamente Integer#times está implementado de una forma muy similar al segundo snippet (aunque en C, no en ruby).

Crear estos metalenguajes—DSLs (“Domain Specific Languages”), implica agregar un nivel más de abstracción a nuestro código. Tenemos que evaluar siempre hasta qué punto la complejidad agregada vale la mayor legibilidad.

Lamentablemente no hay una respuesta única y absoluta. Como mucho en la vida, es un tradeoff que hay que sopesar durante el desarrollo.

¿Qué beneficios reales trae a la mantenibilidad a largo plazo de este código agregar este nivel extra de indirección?

Documentación

El código sucinto y terso suele ser comprensible, pero aún así es muy importante documentar lo que hacemos. No me refiero comentar cada línea de código—no, para eso es que tenemos que escribir código claro.

Me refiero a documentar—en una o dos líneas nomás—el propósito de los métodos, qué se supone que son los parámetros, y qué devuelve.

Las interfaces que escribimos en nuestros programas—interfaz en el sentido Java-esco—son primordialmente para manipular abstracciones. Es necesario que alguien nuevo (o alguien que no se acerca a ese rincón del código hace un tiempo) pueda tirarse a modificar algo y entender cuáles son las abstracciones en juego.

Hay, sin embargo, un par de cosas a tener en cuenta con la documentación. La documentación está pensada—antes que nada—para leerla cuando lees código. Eso quiere decir que, primero que nada, tiene que estar dirigida a humanos.

No hace falta inventarse todo un lenguaje nuevo con tags y gramática y otras convenciones que haya que aprender. Ojo, no estoy diciendo que esto esté mal, si todos en tu equipo están familiarizados con la gramática de una herramienta como YARD, me parece excelente que la usen.

Mi punto es que nuestra responsabilidad es documentar el código para que nuestros compañeros (o incluso nosotros mismos) podamos volver a él y entender qué intenciones teníamos cuando lo escribimos. Para cumplir con esta responsabilidad, tenemos que reducir la barrera de entrada a escribir documentación lo más posible.

En general en los equipos en los que he trabajado trato de promover usar algo parecido a TomDoc. Ni siquiera me esfuerzo demasiado porque sea TomDoc estrictamente—no necesitamos generar documentación fuera del código, ya que este tipo de documentación es para cuando leemos código nomás, por lo que no es particularmente interesante en general que esto se apegue a una sintaxis con demasiado cuidado.

Lo que sí es importante es que ese par de líneas que tenemos ahí que me dicen por qué está ese método, qué son los parámetros que recibe, y qué se supone que devuelva sean legibles y claros. Sus “yo” de dentro de 6 meses van a agradecer que se tomaron esos 3 minutos para documentar el código.

Lo otro importante sobre escribir documentación es mantenerla actualizada. Es horrible encontrarse con algo documentado y creerle a la documentación, solo para descubrir que esa documentación es pura mentira.

Por ejemplo, hace unos meses estaba trabajando en un proyecto bastante complejo, y tenía a un amigo trabajando conmigo. Mi amigo tenía que debuggear un problema con un proveedor externo. Le dijeron “las credenciales para hacer login con este proveedor las podés encontrar en X página de la wiki”.

Una tarde, muchas lágrimas y un montón de pelo arrancado después, alguien más del equipo lo ve en el chat puteando porque no puede hacer login con las credenciales que encontró en la wiki, y le dice “Jeje, no, no. Para ese servicio lo que está en la wiki no sirve, tenés que usar estas otras credenciales”.

*facepalm*

Una forma simple de remediar esto es mantener la documentación cerca del código. Y cuando digo cerca, me refiero a en el código. Es mucho más fácil decir en un Pull Request “no, no mergees este feature nuevo hasta no actualizar toda la documentación de las cosas que cambiaste” que decir “ah, ahora después de mergear esto, acordate de ir a la wiki y cambiar cosas”.

Con los “API docs”, que describen los métodos, esto no es un problema (o al menos es uno mucho más simple de resolver), porque solemos escribir la documentación de esos métodos en el código junto a ellos. El problema se presenta cuando queremos tener documentación más generica.

Quizás de procesos o explicando ciertos flujos que son específicos a la app. Por ejemplo el setup (más sobre esto luego), o explicando la arquitectura a alto nivel, o cómo se integra esta aplicación con otras cosas.

Para esto, mucho mejor que una wiki es tener una carpeta docs/ en el código, donde ponemos archivos en algún formato que nos guste—como puede ser markdown o RST o similar. Ahora es mucho más fácil al ver el diff de un Pull Request si la documentación pertinente se actualizó junto con el código.

Bootstrapping

Hablando del setup de un proyecto, otra cosa en la que vale ser responsables con nuestros pares es en no hacerlos sufrir mucho para poder empezar a trabajar en el proyecto.

El proceso de qué hay que instalar—qué versiones de servicios como Postgres, en qué puertos espera el proyecto que las cosas estén corriendo, o dónde configurar estas cosas, tiene que estar claramente documentado. Preferiblemente en el README del proyecto, o linkeado desde ahí si resulta ser muy largo.

Pero mejor aún que documentarlo, podemos automatizar mucho de esto. Una combinación de buenos defaults en la configuración, y de scripts que se ocupen de chequear dependencias o inicializar lo necesario para que la aplicación corra hacen maravillas a la hora de traer gente nueva al proyecto.

Por ejemplo, suelo poner en mis proyectos dos scripts:

  • script/check que se asegura que las dependencias externas estén instaladas, como son PostgreSQL, Redis, o memcached. Si encuentra problemas, te dice cómo arreglarlo (si hay que instalarlos, o si hay que configurar la app para encontrar estos servicios en otro puerto, por ejemplo).
  • script/bootstrap se asegura de que las gemas estén instaladas, y las bases de datos tengan el esquema correcto y migrado a la última versión. Además, este script guarda un checksum de la lista de gemas, por lo que si no modificamos nuestro .deps o Gemfile.lock no va a tratar de instalar gemas (lo cual puede ser lento, si usan algo como Bundler). Y si no cambió su schema de la base de datos, tampoco va a tratar de hacer migraciones. O sea: cuando no hay nada que hacer, termina en apenas un par de milisegundos, lo cual nos permite llamar este script desde el script que corre los tests, o que abre la consola, o que inicia el server.

Con estos dos scripts ahí, una persona nueva que llega al proyecto lo único que tiene que hacer es correr script/check, instalar cualquier cosa que le diga que falta, correr script/check para ver que ahora todo está bien, y luego script/server (que internamente llama a script/bootstrap). Et voilà! Tiene el proyecto corriendo.

Hablando de defaults inteligentes, la noción de no versionar sus archivos de configuración es medio tonta. El .env que guarda todas las variables de entorno que queremos usar para la app (como la URL de la base de datos o de redis, o la configuración para mandar mails) está versionado, y tiene valores que para la configuración por defecto de las distintas cosas deberían ser suficientes. Por ejemplo:

DATABASE_URL=postgres://${PGUSER}@${PGHOST}:${PGPORT}/some_db
REDIS_URL=redis://127.0.0.1:6379
SESSION_SECRET=deadbeef

Ahora cualquier persona que inicie la app—si tiene los servicios instalados en los lugares normales y corriendo en los puertos normales, no tiene que hacer absolutamente nada para correr la app.

A esto se suma otro archivo—también versionado—que se llama .env.test con los overrides que haya que hacer para los tests. Por ejemplo:

DATABASE_URL=postgres://${PGUSER}@${PGHOST}:${PGPORT}/test_db
REDIS_URL=redis://127.0.0.1:6379/5

Noten que no es necesario definir todas las variables de nuevo. Solo tenemos que cargar el archivo de test después del de development, y sobre escribir cualquier variable que tenga que cambiar.

¿Y qué pasa cuando alguien tiene alguna configuración particular en su environment local? Ahí sí queremos un archivo que no esté versionado donde cada uno pueda hacer lo que quiera para configurar “las cosas raras”. Algo como config/personal.rb donde podamos manipular el environment libremente para setear configuraciones personales. (script/check se asegura de avisarte que como no pudo encontrar X servicio en donde lo espera, deberías configurarlo en tu config/personal.rb). Por ejemplo:

# I run Postgres in a VM because I rebel against the system
ENV["DATABASE_URL"] = "postgres://172.109.10.1/some_db"
if ENV["RACK_ENV"] == "test"
ENV["DATABASE_URL"].gsub!("some_db", "test_db")
end

Este esquema de configuración es simple, flexible, y permite tener defaults que funcionan y que hacen que la gente no tiene que preocuparse en perder tiempo haciendo andar la aplicación cuando recién comienza con ella. En lugar de estar 3 horas para levantar la app la primera vez, estás 5 minutos. O si tuviste que instalar algún servicio como redis, quizás 15 minutos. Pero nuestra aplicación no es el punto de sufrimiento.

Eso es algo que podemos—debemos—hacer por nuestros compañeros.

Simpleza

A los rubyistas nos encanta estar en el Bleeding Edge. Nos encanta ordenar las gemas por versión de última actualización, e incluso penalizamos a las librerías que hace mucho no se actualizan como “menos recomendadas para usar en producción”.

Supongamos que tengamos que usar una herramienta, vemos de cuándo es la última versión, y nos encontramos con que es del 2002.

Ewww, ¡2002! Eso está RE sin mantener. Seguro que debe estar llena de bugs y voy a tener que lidiar con toda la mierda de los developers irresponsables que hace más de 10 años no sacan una versión nueva. Nope, paso, voy a buscar otra forma de hacerlo.

A todos se nos pasó por la cabeza algo como esto en algún momento. Ahora, ¿qué pasa si les digo que esta herramienta del 2002 es ls(1)? La versión de ls que viene en OS X es del 2002. Seguramente haya versiones más viejas en otros unixes actuales.

¿Qué hacemos, entonces? ¿No usamos ls para listar archivos porque hace más de 10 años que nadie la actualiza?

Claro que no. Usamos ls porque funciona. Hace 12 años que ls no se actualiza, no por no estar mantenido, sino porque funciona. Las herramientas del toolchain de UNIX, en su gran mayoría, reciben muy pocos updates. Y funcionan a la perfección.

¿Qué comparten en común, que las hace tan robustas?

Su simpleza.

Todas las herramientas del toolchain de UNIX hacen una sola cosa, y la hacen bien. ¿Se acuerdan de “sem-plex”? ¿Una cosa sola? Esta simpleza hace que las herramientas sean increíblemente robustas.

Herramientas simples, pequeñas, con un scope acotado, y con una interfaz común que permita componerlas para lograr sistemas complejos son la clave a sistemas robustos y mantenibles.

Mañana tenemos la charla de Michel sobre este tema, así que no quiero estar horas hablando de esto, pero sí quiero recalcar el punto:

Concéntrense en escribir software simple. Del software simple se desprende la mantenibilidad. Software simple que además está escrito claramente y bien documentado hace que nuestros compañeros puedan trabajar con él sin problemas. Sin sufrir. Sin convertirse en psicóticos asesinos en unos pocos meses.

Responsabilidad con nosotros mismos

La última responsabilidad que tenemos es para con nosotros mismos. Tenemos que entender que lo que hacemos no lo hacemos para nosotros, lo hacemos para TODO el mundo. Cuando escribímos código estamos afectando a todos los potenciales consumidores del resultado de nuestro código. Tenemos, entonces, que hacer lo mejor para TODOS—no lo mejor para nosotros.

Cuando nos sentamos a escribir software, es importante que pensemos en cómo los usuarios van a interactuar con nuestro programa. Somos responsables de tratar de ponernos en sus zapatos y hacer lo mejor que podamos para ellos.

Es importante que nos pongamos en los zapatos de nuestros pares, quienes van a tener que lidiar con todas nuestras cagadas en el futuro. Somos responsables de que no sufran demasiado, así como a nosotros nos gusta no sufrir demasiado con el código con el que trabajamos hoy.

Somos responsables de hacer del mundo un lugar mejor.

Gracias.

--

--