Mr Dias

Las victorias de los demás

2023-11-05T00:00:00-04:00

He pasado un par de semanas de conferencia y vacaciones por lo que no he participado en el último sprint del equipo.

Cuando he vuelto, he tenido una gran satisfacción al ver que el equipo había completado casi todos los issues que se habían planificado y no habían cosas bloqueadas por mi ausencia.

A la vez he tenido algunas dudas. Si el equipo trabaja bien cuando no estoy ¿es mi rol necesario? Es una pregunta interesante ya que me ha hecho reflexionar sobre mi papel en la empresa.

Una de mis principales responsabilidades es que los ingenieros a mi cargo generen valor para el negocio. Por lo tanto la organización del trabajo es un factor clave y sobre el que quiero enfocarme el día de hoy en esta reflexión.

Qué hacer y el por qué son claves para un buen sprint. A mi me gusta que el equipo entienda la razón de las tareas, sobretodo cuando son difíciles y aún más cuando son aburridas. Si son difíciles para persistir en el esfuerzo durante el tiempo ya que sabemos a dónde queremos llegar. Y si son aburridas (temas regulatorios o reportes por ejemplo) cuál es su importancia y cómo benefician al negocio y también las oportunidades para automatizarlas y con ello transformarlas en tareas más creativas.

El balance de tipo de trabajo es muy importante para mí. Tenemos tareas inmediatas debido a fechas de entrega acordadas o imprevistos que hay que resolver. Hay metas que queremos lograr y aunque sean a largo plazo hay que trabajar en ellas poco a poco. Hay tareas de desarrollo personal que aunque no tengan un objetivo inmediato debemos crear espacios para que nuestros ingenieros mejoren sus habilidades y aprendan cosas nuevas y prueben nuevas tecnologías. Cada sprint es distinto a veces los fuegos nos pueden consumir por completo, afortunadamente no es el caso siempre y las proporciones variarán pero para mí es importante que haya una buena mezcla de tipos de trabajo.

A veces también me doy cuenta que alguien lleva mucho tiempo con un proyecto largo y se le ve cansado, pues aunque tardemos más en llegar a la meta, un sprint de “refrescamiento” suele venir bien y trabajar en otras cosas les da la oportunidad de coger fuerza y tomar un poco de perspectiva sobre dónde estamos y cómo seguir avanzando.

Por último, siendo los ingenieros que están inmersos en los detalles de la implementación intento que sean ellos que definan las tareas y próximos pasos a seguir y yo cada vez más limitarme más a desbloquearlos y que estos se alineen con los objetivos y definir los límites y consideraciones. Reconozco que esto me cuesta mucho, el no estar siempre en “modo de solución” es un reto personal.

Son los ingenieros con su esfuerzo que consiguen los objetivos y su ética de trabajo y motivación propia lo que les impulsa. Pero por el otro que tengan claro lo que hay que hacer es responsabilidad de los líderes, así que bien, punto para mi 😁.

Si has leído hasta aquí gracias por tu tiempo,

Saludos

Gratificación Aplazada

2023-09-27T00:00:00-04:00

Una de las mayores difícultades que he tenido después del cambio a una posición de gestión es la diferencia en la escala de gratificación con respecto a la que tenía por mi contribución individual (Individual Contributor).

Como ingenieros tenemos múltiples oportunidades de realizar pequeñas contribuciones en el día a día. Mezclar una rama y hacer un despliegue nos da la oportunidad de ver los resultados de nuestras acciones y su impacto durante ciclos bastante cortos. En empresas ágiles esto puede ser de días a pocas semanas. Es una generalización, ya hay mucho proyectos que pueden llevar largo tiempo para poner en producción pero suele haber oportunidades de ver el progreso que vamos consiguiendo. Ese momento que resuelves un problema y hace click! “”

En una posición de gestión podemos ver el progreso que realizan nuestros equipos pero la escala de los objetivos es mayor y los resultados se pueden ver en semanas o meses cuando pronto.

Por poner un ejemplo, recientemente mi equipo ha finalizado una importante migración de bases de datos que gestionábamos a un nuevo proveedor. Han sido en total unos 7 meses para conseguirlo. Empezó durante un proceso de auditoría interna. Nos dimos cuenta que había varias deficiencias a solucionar en el sistema para obtener una certificación de seguridad. Desde ese momento empieza la creación de un caso de negocio, evaluación del proveedor, obtener el presupuesto y pasar las evaluaciones de seguridad. Ya que tenemos que gestionar información privada de nuestros clientes esto ha añadido la necesidad de procesos adicionales para usar un nuevo sub-processor, los cuales no estaban definidos siendo este el primero. Así pues, una vez definidos estos se establece algunos requisitos legales adicionales para nuestro proveedor y plazos de notificación de clientes de los cambios. Todo esto ha requerido muchos emails e involucrar gran parte del negocio: Ingeniería, Producto, Finanzas, Legal y Gestión de cuentas. Finalmente esto ha llevado unos 5 meses hasta que hemos tenido el visto bueno y los contratos firmados. En este momento, ya podíamos empezar a trabajar en la migración aunque no podíamos usar los datos de producción hasta pasados 30 días.

Hicimos pruebas en otros entornos y fue todo bastante sencillo. Cuando empezamos a probar con producción surgieron varios retos, como siempre, esta vez debido a la gran cantidad de datos y su distribución así como alguna limitación del proveedor. Afortunadamente la buena comunicación entre desarrollado y sistemas consiguió solucionarlos en poco tiempo. Finalmente la migración se ha realizado tras dos meses de pruebas y ha sido completada con éxito. Ese día si que he estado contento! después de ver el nuevo sistema atendiendo peticiones y con el sistema anterior apagado. Y todo sin incidentes y con un mínimo downtime. Qué más se puede pedir?

Este ha sido realmente el primer proyecto donde mi contribución en código ha sido mínima, y mi participación ha sido realmente en la gestión del proyecto y las personas por completo.

Todos esos emails y obstáculos que iba sorteando fueron pasos importantes sin embargo no me dieron mucha satisfacción la verdad 😂.

Todo esto para decir que algo me “picaba” en Febrero y he conseguido rascarme en Septiembre.

Si has leído hasta aquí gracias.

Saludos

63 pensamientos y lecciones que he aprendido en 2 años como manager

2023-08-20T00:00:00-04:00

He tenido este post en draft durante demasiado tiempo. Empezó como una lista de 6 meses, no me gustaba y al año otro cambio y realmente como me suele pasar lo he dejado de lado por no ser ¨perfecto¨, también escribir en Castellano se me hace raro pero podría ser un cambio interesante para este blog.

Hoy está siendo un día lluvioso y tranquilo, no hay mucho que hacer, todos duermen en casa. El momento ideal vamos, así que allí va.

El equipo es lo más importante. Debe primar el interés grupal sobre el individual.
El trato debe ser justo e igualitario, pero no todos necesitan el mismo trato.
Hay que entender las necesidades de cada uno de los miembros del equipo.
Hay que ser claro con nuestras expectativas y nuestro modo de comunicarnos.
En un ambiente multicultural es mejor ser directo y explícito.
Cada cultura lee entre líneas cosas distintas. Hagamos visibles esas líneas.
Aclarar nuestra posición desde el principio ayudará a evitar malos entendidos.
Ser directo, pero bondadoso. Siempre desde el respeto.
Si crees que te has equivocado, pide disculpas sinceramente.
Es mejor tener una conversación difícil un momento, que pasar mil momentos difíciles.””
Es realmente importante demostrar el aprecio por el trabajo y las cosas bien hechas, aunque sea lo que esperamos de ellas.
Hay que dar buenas y malas noticias y feedback, mejor no mezclarlo.
Si hay algo que mejorar, seamos claros y no intentemos suavizarlo con lo bueno.
Si hay algo que felicitar, no pongamos peros, ya habrá otro momento.
Si somos generosos con el feedback, este es continuo y preciso, el equipo apreciará lo bueno sinceramente y aceptará mejor cuando este sea crítico.
Los 1-1 son las reuniones más influyentes en la relación con cada individuo.
Hay que aprender a escuchar y poner interés en la otra persona.
La empatía es una habilidad y puede trabajarse y mejorar.
Es importante tomar notas de las reuniones y hacerles seguimiento.
Mientras más débil la relación, más importante es tomar notas.
Los errores de hiring son los más caros.
No te apures en contratar.
Es malo tener prisa por contratar, es peor tener prisa por despedir.
Ante la duda, ¡No hire!
Primero la actitud, segundo los skills, aunque se necesitan los dos.
Mejor junior con buena actitud que sénior con acritud.
Si es sénior y tiene buena actitud, da gracias a la vida.
Es más fácil enseñar la técnica, que enseñar a pensar.
Todos en el equipo deben estar para ayudarse. Busca gente que pueda y quiera sumar.
Marrón que te comes tú, marrón que evita el equipo.
Hay que saber repartir los marrones.
Si eres justo, lo aceptarán sin mucho problema.
El manager debe llevar al equipo, no al contrario.
Es importante mantenerse optimista y motivador.
Es muy duro hacerlo consistentemente.
Si tienes problemas habla de ello con tu propio manager. No cargues al equipo.
Intenta ser el manager que te hubiera gustado tener.
Trabajando en remoto la confianza lo es todo.
Resultados == Confianza.
Resultados == Flexibilidad.
Como manager, se explícito en la frecuencia con que esperas recibir información.
No pierdas de vista tus metas por el día a día.
Las metas pueden cambiar y debemos revisarlas y ajustarlas durante el año.
Las metas nos indican una dirección a seguir, no un camino fijo.
Si alcanzas todas tus metas es porque no eran ambiciosas.
Si no alcanzas ninguna es porque no eres realista.
Mejor completar la mitad de las metas, que la mitad de cada meta.
Tan importante como lograr las metas es el esfuerzo que ponemos en tirar en esa dirección aunque no lo logremos.
No hay tiempo suficiente para hacer todo lo que queremos.
Prioriza las tareas que te ayudan a lograr tus metas.
Si trabajas mucho en tareas que no están alineadas con tus metas, piensa en cuál es la meta oculta y dale visibilidad.
Todo el equipo debe ser partícipe de las metas y cada miembro debe ser responsable de algunas de ellas.
Es normal tener dudas al cambiar a gestionar desde un rol individual.
Es normal querer e intentar hacer los dos trabajos al principio, pero no es sostenible.
Lo más difícil es aprender a no hacer el trabajo individual.
Delega el trabajo pero no la responsabilidad. Debemos acompañar y supervisar al equipo.
Cuando hagas trabajo de IC, enfócate en lo importante pero no urgente. No seas cuello de botella para los demás.
Nunca harán el trabajo igual que lo harías tú. Enfócate en los resultados y los aspectos fundamentales.
Si te molesta algún pequeño detalle insignificante, entonces no le des importancia y aprende a ignorarlo.
No siempre hace falta tener que decir algo.
La sensación de obtener un logro cambia de escala. Pasan meses o años para que se puedan observar los resultados de los esfuerzos.
Tengo más aprecio por mis anteriores manager. Buenos y malos.
Entiendo ahora que algunos tenían demasiada gente a cargo, muchos no querían estar en ese rol y los menos serían personas egoístas o ineptos.

Escribiendo este post he pensado en retrospectiva sobre algunas situaciones e interacciones con managers del pasado y veo que mi forma de actuar no fue correcta y ahora entiendo que estaba equivocado.

Ser manager es un rol que puede no ser apropiado según el momento de cada uno, teniendo tal influencia en la vida de la gente bajo su cargo y los resultados de la empresa quienes ejerzan ese rol deben hacerlo con vocación y convicción.

Ser manager es un reto, hay que estudiar y aprender mucho sobre los demás y sobre nosotros mismos. Después de dos años ya no tengo dudas sobre haber elegido el camino correcto para mi en el momento en que me encuentro.

Me considero muy afortunado por el equipo que tengo, y que me acompaña en este aprendizaje y que sinceramente espero no dejar muy traumatizado ;)

Si has llegado hasta aquí muchas gracias por leerme y espero que de algo te haya servido o te haya hecho reflexionar.

Suerte!

Creating jenkins users and tokens programatically

2020-06-03T00:00:00-04:00

At work we manage a jenkins setup and rely on Google for authentication. One drawback is managing service users that do not have an email. We use those for interacting with the jenkins API in scripts.

When you use the Google Login plugin you no longer see the option to manage users in the UI, fortunately we can leverage the Jenkins Console and provision those users and generate the API tokens we need.

Let’s create some jenkins users and give them a username and password.

Go to the jenkins console on JEKINS_URL/script.

To create a user you can execute:

    import static hudson.security.HudsonPrivateSecurityRealm;
    HudsonPrivateSecurityRealm securityRealm = new HudsonPrivateSecurityRealm(true, false, null);
    securityRealm.createAccount("USERNAME", "PASSWORD")

To generate an API Token for the user:

    import hudson.model.*
    import jenkins.model.*
    import jenkins.security.*
    import jenkins.security.apitoken.*

    // script parameters
    def userName = 'USERNAME'
    def tokenName = 'kb-token'

    def user = User.get(userName, false)
    def apiTokenProperty = user.getProperty(ApiTokenProperty.class)
    def result = apiTokenProperty.tokenStore.generateNewToken(tokenName)
    user.save()

    return result.plainValue

This last script can be used to (re)generate API tokens for any user.

Remember to use the API token to authenticate instead of the password.

To verify it works, run:

    curl -u USERNAME:API_TOKEN https://jenkins.example.com

Get to know your editor

2018-04-23T00:00:00-04:00

As programmers we spend most of our time (apart from meetings :p) editing text. I’m a very avid user of emacs. I’ve been using the editor since 2007 after a friend took the time to explain it to me. I had tried to use it at university but couldn’t understand how to use it, I tried also vim and it was even worse, so I ended up using something a bit friendlier like gedit back then. Anyway, this is not about which editor is better or worse but about sticking to something.

After I started learning emacs and really trying to use it for a while it started to click. I was starting to work with Ruby around the time and the support for it was quite good, Matz uses emacs so it’s not a coincidence. I’ve then used emacs for many other programming languages, javascript, python, golang, etc. Every time I try a new programming language I improve my emacs to support it, I’ll configure plugins or write some functions and then I can work with this language using the same workflows and tricks I’ve learned through the years.

I’m not trying to advocate using emacs, that is just a choice, but after more than 10 years using it I can be very productive. So you can do it too! When I started I didn’t know all the things I could do with my editor but I’ve definitely dedicated time to learn it and I’ve only scratched the surface of what it can do. Knowing your editor takes time and effort but it totally pays off.

There are many great editors out there, we’re way past the vim vs emacs debate. Those editors though great are not for everyone, try different editors for a while until you find the one that feels right to you. You won’t know it immediately but after a couple of weeks or a month you will and then you can choose whether or not to continue using it.

I recommend also watching how other advanced users do things with different editors, you get many good ideas that you can “steal” for your use without having to necessarily change your tools.

My recommendation is if you’re struggling with your editor just try something different, try a change that will help you in the long term, once you master your basic tools you can then move on and tackle higher level issues about how you work. If you’ve been using the same editor for a while and are comfortable with it try to push your boundaries. Look for tutorials or demos, investigate the menus, read the documentation, there’ll be tips and tricks that you can slowly add to your bag. Don’t try to learn everything in one day, do it regularly, a little bit (5 minutes?) every day and you’ll see how you master your editor sooner than you may think.

Here are a few links that could be of interest.

Mastering emacs Emacs is sexy How to learn vim a four week plan Openvim Visual Studio Code tricks

Pair programming Dos and Don'ts

2018-04-02T00:00:00-04:00

There are several things that will make your pair programming sessions work better. Things you can actively do and others best to avoid.

First of all, you need to give it an honest shot, especially if you’re not experienced in pairing. Pair programming is a skill and needs to be learned. Like learning any other thing the process can be tough, it can take you out of your comfort zone and get your mind resisting and wanting to do things as usual. So it’s important to be open about the experience and try to make the best of it.

Communication is crucial, you need to talk to your partner and learn to listen. There is a quote by Donald Knuth which I really like that says: “Programming is the art of telling another human being what one wants the computer to do”. This has always stuck with me since I first read it and when you’re pairing it applies even more. That’s the essence of it.

Effective listening is necessary, listening to others is by no means easy! Try to open to their suggestions and be aware of the interaction you have with your partner. Don’t rush through the task, take the time so both understand clearly the goal.

You need to be patient, you may have a very clear idea but your partner may not understand so try to explain things and help them understand. Use a notebook or a drawing board, don’t get frustrated if you need to repeat things many times. At the same time sometimes you just need to trust your partner. You may not understand clearly despite their best intentions or may not exactly agree on how to do things but let them show you their way. If after all the idea doesn’t work out you’ll both get something out of it, and the next attempt will work out much better as you won’t have to make the same mistakes.

Code written by a pair is a construction of the best ideas by two people and coming up with them, things need to be challenged. You’ll need to convince your partner and in some occasions you’ll need to convince yourself, so it’s important to leave the old ego at home! It’s not a competition nor is it about being right or wrong so questioning and discussing are vital and need not be taken personally. Remember the deliberation is all about the ideas not the people.

Be respectful when talking, try to avoid using bad words and expressions, try to keep the session positive even when faced with challenges (bugs, bad documentation, some third party failing, etc). Stay positive! A good mood will help the sessions be lighter and less stressful for both. And it’s ok to keep your partner in check, if they are being cranky or moody let them know and help them cheer up.

Taking regular breaks is also advisable. When you’re pairing a lot of the little distractions that plague us will vanish. Writing emails, checking slack, reading blogs, twitter, news sites, etc is not something you can do with someone next to you so the increased focus will be draining after a while. When you feel tired go for a coffee or go for a walk, try to change the environment so that you can recharge and get back into action feeling fresh.

Last but not least, you’ll be working shoulder to shoulder with someone so consider your personal hygiene and avoid using too much perfume or after shave as some people may be sensitive to it.

This is not an exhaustive list but by using these points you’ll see how your pair programming sessions become more enjoyable and after practicing some time you’ll get acquainted and see how working in this way is worth it.

Using magit with Github Enterprise

2018-04-01T00:00:00-04:00

I’m a big fan of magit and I’ve been using it for many years and I found some time ago the magithub extension, which is great and allows you to integrate with github, see your pull requests, open the browser for the current project, create PRs, etc.

The main difficulties I had were getting it to work with GHE, I had to do some hacks to get it working like a year ago but it was good and I moved on.

Now I recently had to setup a new computer and the newest version of magithub has changed and my previous configuration didn’t work.

After reading the documentation for magithub, ghub and ghub+ I was still having some problems so after some debugging and reading the source code I found how to make it work which I’ll document here for future reference.

From the magithub FAQ the first thing you need is to setup the correct value of magithub-github-hosts. I tried to customize it but there seems to be a problem and emacs (25.2.1) doesn’t let me use a list so in my .emacs config I added.

(setq magithub-github-hosts '("github.com" "ghe.example.com")))

Following the ghub manual the first thing you need to do is setup your username:

git config --global github.user USERNAME

# For GHE
git config --global github.ghe.example.com/api/v3.user EMPLOYEE

Then for each corporate repository you should do:

cd /path/to/repo
git config github.host ghe.example.com/api/v3

Now in my case I added a conditional include in my ~/.gitconfig to set this globally for all the work repos (which I have under the same root folder).

So my ~/.gitconfig would include:

[github]
	user = diasjorge

[includeIf "gitdir:~/development/work/"]
        path = ~/.gitconfig.work

And in ~/.gitconfig.work I’ll have:

[user]
        email = jorge.dias@example.com
[github "ghe.example.com/api/v3"] # Magithub uses this to make the API requests
	user = jorge-dias
[github] # Make ghub always use this user and host
	user = jorge-dias
	host = ghe.example.com/api/v3

Now with this setup I have seamless integration and I don’t have to remember to configure the github.host for all my repos.

Then you need to configure your ~/.authinfo file. Following the manual I added:

machine api.github.com login user^ghub password TOKEN
machine api.github.com login user^magithub password TOKEN

machine ghe.example.com/api/v3 login ghe-user^ghub password GHE_TOKEN
machine ghe.example.com/api/v3 login ghe-user^magithub password GHE_TOKEN

Notice I add different entries for ghub and magithub packages. This is so you can give different packages that use ghub different permissions.

For magithub the variable magithub-github-token-scopes mentions the required scopes '(repo user notifications).

It took me a while to figure it all out so I hope you find this summary useful and you can enjoy working with magit and Github enterprise using magithub.

Cheers!

Pair programming revisited

2017-12-22T00:00:00-04:00

I’ve always liked pair programming, since my college times. I remember doing coding exercises spending late nights at the computer lab and we were always working with your partners. And you would talk to everyone in the room trying to figure out how to solve things, you’d sit with people from other teams and share code. I didn’t know you’d call this pairing then.

And then I started doing an internship to get my degree, and I was assigned a project with someone from my same university. And we would work together a lot, we’d sit together solve problems we had with Enterprise Java Beans (OMG!!) the Oracle web server and related technologies of the time for hours. And we’d code together on the same things, sometimes at my computer or his and I still didn’t know it was called pair programming.

And as I started working after I moved to Spain I was working as a consultant and I didn’t do much of that. Yes I’d talk to colleagues and solve some things together but it was not well seen to work together. How can you have two people working on the same thing? It would take double to get things done they’d say.

And then I had my first Rails job, a totally different environment, and we worked together a lot, sit with someone for many hours solving some problems, debugging, creating things and having fun. It was at this moment when I started to learn about pair programming.

It was a thing, doing that which always seemed to me like the best way to work actually had a name. And there was a lot of people that talked about this subject, a consultancy like Hash rocket would do it and talk about it, what worked well for them and it was good to realise there was a movement of people promoting this work.

And so since then I’ve had a few jobs and I’ve always been bit of a proponent of it and I’ve always tried pairing whenever possible since I enjoy working with others this way.

The software we’re building is getting more and more complex with time, the demands of our users become ever increasing and we’re required to handle many different parts. With micro services and the cloud this is only getting harder. And for me it’s becoming more clear that in order to solve this things what we need is more collaboration and that pairing is a more effective way of getting work done.

There is only so much information one can keep in their heads when you are pairing you have much more capacity. When you have a good partner and you’re driving you can feel more relaxed since someone else is spotting many little mistakes that help things flow better instead of hitting them and having to fix them.

When tackling a problem and there’s a need to discuss things and you’re pairing you have immediate access to a smart person sitting next to you to help you discuss alternatives and make a decision.

Writing tests for a feature and having a partner is very useful going through edge cases, suggesting possibilities that you haven’t considered making sure things are more robust from the beginning.

All the features done with a partner get an automatic +1. Features developed pairing are better designed and more robust and other team members will feel usually more inclined to accept them.

Pairing is a social skill that needs to be developed, it’s not the most natural way to work for people, you need to learn how to work with your partner when you’re writing the code and when you’re the “co-pilot”. It takes time to break old habits too, getting rid of the constant distractions and focusing on the task with your partner can be challenging.

Switch AWS accounts easily using roly

2017-12-20T00:00:00-04:00

Many companies keep their AWS accounts separated per environment, per team, etc and you can find yourself in a situation where you have users and credentials on many different accounts. From a security perspective this is not ideal as managing this can be very hard, people will change teams, leave the company, etc and cleaning up their access on all accounts can be very tedious and time consuming.

A way to deal with this is by having a user in one account and then assume role in another account so there’s only one place to manage your users and credentials.

I’m going to assume you already have knowledge about how to create a role in the target account and configure your ~/.aws/credentials file. If not AWS has a good basic introduction here.

This has some advantages for security but if you are using MFA it can be a bit more tedious to have to constantly type the tokens. The AWS CLI when you give it the --profile flag will perform an STS:AssumeRole call for you an cache the results for one hour.

This can be sufficient for your needs but if you’re working with some of the SDKs like boto you may encounter some problems. If you’re using ansible it uses boto2 underneath which doesn’t support profiles to assume role with MFA. Boto3 works correctly but you need to provide the MFA token on every invocation since it won’t cache sessions for you.

To make my life easier and some colleagues while migrating from boto2 to boto3 I created a very small tool called roly.

The AWS SDKs will respect the AWS_* environment variables you have set and roly just leverages this fact.

You can use roly in two ways:

$ roly export target-profile
Assume Role MFA token code: XXXX
export AWS_ACCESS_KEY_ID='XXXXXXXXXXXXXXXX'
export AWS_SECRET_ACCESS_KEY='XXXXXXXXXXXXXXXX'
export AWS_SESSION_TOKEN='XXXXXXXXXXXXXXXX'

If needed will prompt for your MFA token and then it will print the commands needed to set your environment variables. The session will last for an hour. Copy and paste them and you’re set.

Or you can set the credentials and call a command just once.

$ roly exec target-profile command

You can find the source and binaries at the github repository.

I hope you find it useful.

Fast directory navigation using the CDPATH

2017-12-11T17:42:23-04:00

For a long time I’ve used my own command alias to navigate through my work related projects and jump to them using the cx

Originally the x comes from Xing where I worked at the time. It also happens that the letter x is located next to the c which makes it very convenient like cd.

Anyway imagine you’re in any directory on your system and you want to change to ~/development/work/boring-project normally you’d do something like:

cd ~/development/work/boring-project # or
cd ../../boring-project

Now this can get very tiresome depending where you are and having to get right how many directories levels to go up, etc. Fortunately for us we have the CDPATH environment variable.

We could set in our bash_profile

export CDPATH=~/development/work

and then in our previous example we could have just done cd boring-project.

If we had a directory foo in our current path and a project named foo in our CDPATH in that case you’d be taken to project foo which may not be what you want. So some people recommend to set the CDPATH like:

CDPATH=.:~/development/work

Now in my case I don’t want to change the default behaviour of the cd command so that’s were my cx command comes in.

You can copy this into your bash_profile.

# Change to match your needs
export CXPATH=$HOME/development/work

cx() {
    CDPATH=$CXPATH cd $@
}

_cx() {
    CDPATH=$CXPATH _cd
}

complete -o nospace -F_cx cx

With this when you type cx you’ll get autocompletion too for the projects in your CXPATH regardless from where you are.

Enjoy!

Blog redesign

2017-12-09T00:00:00-04:00

It’s been a while since I worked on the blog’s design. The design dated back to 2011 which is like an eon in Internet time and I didn’t particularly liked how it looked anymore so I decided to change it.

I normally don’t do any design work and CSS is not something I’ve enjoyed particularly but I’ve always used this space to work on that area.

I must say that css has greatly improved over the years. I didn’t have to do anything to make it look the same on different browsers. The tooling in google Chrome is just amazing nowadays. You can see exactly how different elements look, their box size, paddings, margins, etc. It’s a different experience from what I remembered and I enjoyed the whole project quite a bit.

I’m a big fan of solarized. I use it on my editor and on the terminal so I figured having my blog with solarized would be a great idea :)

I used solarized-css for the color scheme with the reset from skeleton I had from my previous design.

One of the major changes is that the design was done for mobile first and then changed it to adapt for bigger screens. I borrowed some ideas about it from some blog posts like this about doing media queries based on your content and not defined screen sizes. I didn’t use any responsive layout framework like skeleton and just used css-grid now that most browsers support it to define the content structure.

I’m happy with the end result, it’s more up to date with my preferences, I like that it’s more colorful and less sober than it was. I learned some new things and specially I had fun doing something I’m not used to which is a great way to push myself and get out of the comfort zone.

I hope you enjoy it too.

Packaging AWS Lambda dependencies using docker

2017-03-09T00:00:00-04:00

Recently I’ve been using AWS Lambda at work for some projects and one of the limitations that you have is trying to use packages with compiled dependencies.

Compiling them on your machine won’t work and the “recommended” way is to start an EC2 instance and compile your dependencies there and then copy those to your machine back.

Fortunately AWS now provides a docker image for amazon linux which we can leverage to build our depencies. We can avoid launching an instance and get faster results.

Below I provide an example to build the dependencies for a python project but you can probably modify it for other cases.

Just put the following content in a Makefile.

compile:
	yum install -y gcc libffi-devel openssl-devel python27-virtualenv
	virtualenv /tmp/venv
	/tmp/venv/bin/pip install --upgrade pip setuptools
	/tmp/venv/bin/pip install -e .
	cp -r /tmp/venv/lib/python2.7/site-packages/. ./aws_lambda_libs
	cp -r /tmp/venv/lib64/python2.7/site-packages/. ./aws_lambda_libs

lambda-deps:
	@echo "--> Compiling lambda dependencies"
	docker run --rm -it -v ${CURDIR}:/src -w /src amazonlinux make compile

.PHONY: lambda-deps compile

Then you just need to execute:

make lambda-deps

When this process finishes you’ll have your dependencies compiled in aws_lambda_libs.

Just include those contents at the root of your package.zip and deploy.

Enjoy!

Using docker containers with your existing rails app

2015-03-08T00:00:00-04:00

This tutorial is an extraction from a talk I recently presented about docker and rails apps at the Barcelona on Rails user group. I’ll explain how to integrate docker into an existing rails app workflow.

Dockerizing our dependencies

The first step to integrate docker into our workflow is to start with our application dependencies.

As an example I’ll use the open source app fulcrum. I assume this application is running locally as would be the case with an existing rails app. For this example we’ll use the postgresql database.

So the first thing is to initialize our database container. For that we execute the following command.

docker run -d --name fulcrum-postgres \
-e POSTGRES_USER=fulcrum -e POSTGRES_PASSWORD=fulcrum \
-p 5432:5432 postgres

So we’re creating a container and run it as a daemon (-d), we setup some environment variables (-e) for the username and password and make the ports available (-p HOSTPORT:CONTAINERPORT).

Now we need to adjust our config/database.yml, it should look something like this:

development:
  adapter: postgresql
  encoding: unicode
  database: fulcrum_development
  pool: 5
  host: <%= ENV['POSTGRES_HOST'] %>
  username: <%= ENV['POSTGRES_USER'] %>
  password: <%= ENV['POSTGRES_PASSWORD'] %>

test:
  adapter: postgresql
  encoding: unicode
  database: fulcrum_test
  pool: 5
  host: <%= ENV['POSTGRES_HOST'] %>
  username: <%= ENV['POSTGRES_USER'] %>
  password: <%= ENV['POSTGRES_PASSWORD'] %>

And now we run our rails app

# Initialize the db
POSTGRES_HOST=`boot2docker ip` \
POSTGRES_USER=fulcrum \
POSTGRES_PASSWORD=fulcrum \
bundle exec rake db:setup

# Run the app
POSTGRES_HOST=`boot2docker ip` \
POSTGRES_USER=fulcrum \
POSTGRES_PASSWORD=fulcrum \
bundle exec rails s

Please note that for the value for the POSTGRES_HOST I’m using boot2docker, if you’re running on linux or against another docker host replace this accordingly.

Now when we visit localhost:3000 our app will be running against our database in a docker container.

For a more complicated app, we’d do the same for the rest of our dependencies. By starting with the dependencies, we are preparing the road so we can have a more decoupled environment while maintaining our regular workflow.

Dockerizing the app

The next step is to run the application itself inside a container. For this we’ll need to create our Dockerfile.

There are many different places to start from. We’ll use the official ruby 2.1.2 container since this is the ruby version our app needs, but defining our own from scratch is quite easy as well.

Our Dockerfile should look like this

FROM ruby:2.1.5

RUN apt-get update && \
    DEBIAN_FRONTEND=noninteractive apt-get install -y \
    nodejs \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /app

COPY Gemfile* /app/

RUN bundle install -j4

ADD . /app

# Let's create a user to run the app that is not root
RUN usr/sbin/useradd --create-home --home-dir /app --shell /bin/bash fulcrum

RUN chown -R fulcrum:fulcrum /app

USER fulcrum

CMD ["rails", "server"]

We also need to tell docker certain files we don’t want as part of our container, we create a .dockerignore file like this:

.git
.bundle
vendor/bundle

After creating the files in the root of our app we execute:

docker build -t fulcrum-web .

Once that is finised we can run our app like this:

docker run --rm -p 3000:3000 --link fulcrum-postgres:postgres \
-e POSTGRES_HOST=postgres \
-e POSTGRES_USERNAME=fulcrum \
-e POSTGRES_PASSWORD=fulcrum \
fulcrum-web

So what is this doing exactly? We’re linking our database container to our web container (–link), we’re exposing the port 3000 (-p) and we’re also setting environment variables (-e) with the values we used when creating our db container. After executing this we can go visit our app running on http://DOCKER_HOST:3000

The first thing we can see is that we have to set many duplicate environment variables from the database when running our container, fortunately docker allows us to have access to a linked container environment variables.

We can change now our config/database.yml replacing the username and password like this:

username: <%= ENV['POSTGRES_USER'] || ENV['POSTGRES_ENV_POSTGRES_USER'] %>
password: <%= ENV['POSTGRES_PASSWORD'] || ENV['POSTGRES_ENV_POSTGRES_PASSWORD'] %>

We rebuild our container again, and now we can start it simply like:

docker run --rm -p 3000:3000 --link fulcrum-postgres:postgres \
-e POSTGRES_HOST=postgres \
fulcrum-web

Now, recreating our container every time we make a file change is going the get very annoying quite soon. For this we can also leverage another docker facility called volumes. This will allow our container to have access to our local files. To do this simply we start our container like this:

docker run --rm -p 3000:3000 --link fulcrum-postgres:postgres \
-e POSTGRES_HOST=postgres \
-v $PWD:/app \
fulcrum-web

Note: Please make sure you delete your .bundle/config local file to avoid issues with bundler inside the container.

Automating our setup with docker compose

At this point we have our app running successfully inside a docker container, but having to be typing this commands constantly is not fun.

To finish our setup we’ll use docker compose.

So let’s create our docker-compose.yml.

web:
  build: .
  links:
    - db:postgres
  environment:
    POSTGRES_HOST: postgres
  ports:
    - "3000:3000"
  volumes:
    - .:/app

db:
  image: postgres
  environment:
    POSTGRES_USER: fulcrum
    POSTGRES_PASSWORD: fulcrum

Now to run our app we simply do:

docker-compose up

The first time we access our app it will complain our db is not created we can simply fix this by running:

docker-compose run web rake db:setup

And last but not least if you want to run your tests then you can simply do:

docker-compose run web rake db:test:prepare spec

The end

So that’s it, I hope this tutorial helps you get started with docker with your existing rails applications. If you want more info about docker compose, check out my article about fig (docker compose’s predecesor) here

Faster docker containers development using fig

2014-12-19T00:00:00-04:00

Yesterday I had the opportunity to present a lightning talk on the Barcelona Docker Group about working with fig.

During the talk I presented a tool that is helping me focus on developing the different containers and make the changes to the Dockerfile and the apps themselves and leave out the details of using fig.

The tool is called guard-fig. It builds on top of guard to detect changes to your fig projects and will stop and rebuild the corresponding containers as well as restarting the linked containers to keep everything working smoothly. It also offers configurable integration with boot2docker and building your whole project on start.

If you’re working with fig, give it a try and report any issues.

You can find the slides for my talk here

Enjoy!

Changing to devops

2014-12-09T00:00:00-04:00

It’s been over 3 months since my change to the site operations team at Xing and time has really been flying by.

Everything is new and I really don’t know what to do many times and that I find very delightful. The investigation, learning, figuring out how to achieve something, reading forums or stack overflow and trying to fit a puzzle into your head. I think this is what I love the most about computers, that moment when you understand the machine, what it does and why it does it. It’s the hack, making the computer do what you want. Getting out of my comfort zone is helping me appreciate the basics more.

During this time, I’ve played with many technologies, different programming languages, libraries, etc. It’s not about a product anymore I care, it’s about the platform. Even though I’m immersed in some low level details about the systems most of the day, the work itself feels at a higher level. The components are bigger and so are their interactions. I could compare caring about an app with caring for a model, the whole database instead of my schema.

But not all is about technology, the human side is very interesting as well. I get to interact with most of the engineers working in the company, so I talk to a very diverse range of people. Different languages, cultures, backgrounds, etc and I have to say most people are actually very grateful when you help them out. Others just seem like they don’t know how to ask things and I have to work on my patience, frustration can sometimes make us say the right things in a very wrong way, this goes for both sides. I also find that I’m more mentally drained when I finish the work. I guess it just takes a lot of energy to be constantly solving other’s problems even if it’s also very regarding.

I’m really enjoying this big new learning experience. I feel there are so many opportunities as when I started learning Ruby on Rails around 8 years ago. I see this as a new beginning, an evolution from developing software to developing platforms.

Growing a garden

2014-07-03T00:00:00-04:00

A couple months ago I started growing a vegetable garden at home with my girlfriend. It’s been a great experience. She’s always been into plants, we have lots of them around the house but never had we tried to grow food. I think the fact that I can get something out of the experience that is more than just aesthetic but also functional (I can eat the vegetables) has made it more appealing for me.

There have been some experiences so far that I somehow can relate with developing a software project.

A garden needs continuous care just like a software project. I need to constantly take care of it, I need to water it constantly just like a project needs your constant development.

As it grows some of the plants leaves start looking bad and so they need to be trimmed, just like in any of our projects you need to keep your code tidy and keep doing small refactorings. If I don’t trim the plants then they start loosing strength, the bad leaves consume energy from the plant, the same as rusty and buggy code drain energy from your project.

Since we’re very new at this we’ve made plenty of mistakes, giving the plants too much water or too little, not knowing exactly how to cut the plants, etc. The same as starting to use a new framework or library and you still don’t know how to do it “the right way” and make many mistakes. Fortunately google is as helpful to find information about gardening as it is to help you find the right answers about development.

Some time ago we got a plague in our tomato plants, some bugs (literally) are attacking it. When I noticed it I felt very sad. I’ve been working a lot of my garden and now some ugly bugs are destroying it. I think any software developer can relate to this one. Anyway, although some damage has been made, I’ve bought some ecological pesticide and now things are starting to get better. Sometimes you can only learn the lessons the hard way. My immediate reaction was to go and buy anything that would kill the bugs but we needed something that would kill the pest and allow us to be able to eat the vegetables later. When working on a software project we want to solve bugs very quickly but we have to keep in mind as well the long term goals and try to find the right solution. It’s best to find the right solution and avoid something that could cause more harm than good.

And finally as with any software project what a great feeling it was when we made a deployment. One of the lettuces had fully grown and it was ready to eat. I can’t describe the nice warm, fuzzy feeling I had to eat something that I helped to grow. It’s such a good feeling to enjoy something you’ve invested your time and effort into it. Besides the lettuce was really fresh (can it get any more fresh?) and crunchy.

I hope to keep growing more vegetables, learn about them and get better at it, just like with any technology.

My recommendation, start growing your own small vegetable garden, I think you can learn a lot about yourself by doing it.

Happy ~~hacking~~ planting!

Barcelona GDG Devfest 2013

2013-10-12T00:00:00-04:00

I was invited with my friend Jean Carlos Meninno to give a presentation on the GDG DevFest Barcelona 2013. It was a great opportunity to talk about the work we’re doing recently for XING and the things we’ve been learning about developing large scale backbone applications.

Here you can find the slides: http://diasjorge.github.io/google-dev-fest-slides/

Hope you like them.

Closed doors open source

2012-09-10T00:00:00-04:00

During my time working at XING I believe my single biggest contribution for the company is a side project I’ve developed called Xing scripts. This project started with a personal need for working with our development environment in a more automated way. I’m a big proponent of automating everything you can and so when I started working I realized that there were these tasks that I would do over and over again. Since I couldn’t bare doing all this manual work I started writing my own scripts.

One day I showed them to one of my fellow team members and he liked them very much. They were just a mix of quick and dirty ruby and bash scripts. Some other people wanted to use them too so I started packaging them as a ruby gem. And then this scripts began evolving. I kept adding more features and it felt good. Through word of mouth more people started hearing about them and asking for support for their own applications, so I did. With time the gem started to gain more traction inside the company and people have started sending patches to add other features and supporting many more applications. This has been very regarding for me, many people have praised me for the work I’ve put into this, since it helps them work much faster.

When a new project is started one of the first things they do, or ask me, is for support with the xing scripts, this fact helps me feel like I’ve accomplished something very good and that my work on this project is important to many people and for the company as a whole. This feeling is the same when I do Open Source, when someone uses one of my projects or when I collaborate on another project. The lessons I’ve learned while working on this project have been many, from a technical point of view as well as personally. For my “regular” work I’m basically doing web stuff with Rails, but this has been an opportunity to work with Ruby on something non web. I had some experience doing command line applications but none of this scale. With the growth of the number of features and applications that need to be supported I’ve had to solve some very interesting problems. I’ve learned a lot about OOP and software design, testing CLIs and how they interact with other services, the importance of semantic versioning, creating a ChangeLog, writing proper documentation, giving support to the users, “selling” your project, etc. All these things that are not part of my daily work and that without this project I couldn’t have learned.

I guess the lesson here is that you can create stuff to solve your own problems and maybe other people’s too. Other people might be struggling with the same problems and have their own solutions, so you can unite and work together. Open source doesn’t have to be code on github, it can be internal projects inside your company, whether they’re tools, libraries, silly web sites, etc. just share them.

Enjoy!

Git rebasing without conflicts

2012-07-11T00:00:00-04:00

Yesterday I was at work with a colleague and we wanted to merge a long-running branch we had. This branch was full of useless commits so we wanted to clean it up. We tried an interactive rebase but we got a lot of conflicts since git doesn’t know how to resolve merge conflicts that we had previously fixed. As you probably know this is no fun, so we did what any sane person would do and found a nice solution for this called git-rerere.

This command allows you to record the way you resolve conflicts and then reuse them when doing automerges in the future. But there’s a drawback to it, first you have to enable an option and second you have to record this solutions as you do them. If you didn’t know about this command before then you didn’t record those solutions and you’re at the same point where you started. Don’t worry there’s a solution it’s called rerere-train, it’s a contrib script from git which recreates the rerere database from your existing commits, this is exactly what we need…awesome!!

So how do you use it? It’s very easy. First you have to enable git-rerere like:

git config rerere.enabled true

Then download the script to somewhere in your $PATH and then do:

sh rerere-train.sh YOUR-LONG-RUNNING-BRANCH-NAME

You have to wait some time so it does it’s work and it’ll depend on how long is the branch. After it finishes you can do the rebase. something like:

git rebase -i master

And now git will know how to resolve the conflicts for you. Enjoy!

Using chef to setup your OSX environment

2012-05-11T00:00:00-04:00

Recently I had to reinstall my computer at work since I had to update to Lion and I could only do a fresh install, so I decided to try to automate the installation process since some of my colleagues are going through the same and it seems like every time we have to waste many hours or days to solve the same issues over and over.

A few days before I had stumbled upon this article just by coincidence and it gave me some light into what could be done. This article led to a previous one by the same author about using chef to manage his workstations I knew what had to be done.

So when I finally decided to tackle the problem I found a nice addition to the whole package which is a gem called soloist.

Soloist makes it very easy to setup your environment and hides lots of the complexity of using chef-solo. Basically it just needs a very simple file structure to know about your cookbooks and a configuration file where you specify the recipes that you need.

I started to use it, but then I got into a few problems. The first one is that chef 0.10.8 had some problems with your USERID if your account is created by Active Directory (which of course was my case), so I had to install chef 0.10.10.rc.3. This made it work. ~~I also found that the soloist version from rubygems at the moment (0.9.4) did not allow to pass node attributes so I had to build the gem from the latest HEAD on the git repository.~~ UPDATE: a new version of soloist was released that fixes that issue.

After reading many of the recipes from pivotal_workstation I chose the ones I liked the most and in the end things worked as you could expect, I did make some changes to some of the recipes to suit them better to my needs and to deal with a bug in chef with symlinks, although if you’re using a stable chef version perhaps you should be fine. I found other useful cookbooks as well and incorporated them to my soloist project and I even wrote some of my own recipes (which I have to say was very easy).

So in conclusion I’m hooked, I know all my macs (and maybe pc’s as well) will have to be installed like this in the future. This was as well my first experience working with chef and it was a very pleasant one even though I had some problems, but that’s the price to pay for being on the “bleeding” edge.

Slow down, you are programming too fast

2012-02-29T00:00:00-04:00

As a programmer, the impetus to go as fast as you can is to be taken with caution as it helps you move forward but it can also hold you back.

Many times I’ve heard about “being in the zone” and sometimes I’ve had this feeling when code is just flowing from your hands but this state of mind is very tricky as you start to relax and stop being conscious. Being aware of what you’re doing and the road that lays in front of you is key to achieve your goals and not fall in mental traps of comfort.

Many times the lack of experience combined with great aptitude can lead to a feeling of trying to compensate with speed. Pure speed is akin to raw force, it can only get you so far. Great programmers are not measured in “Keystrokes per minute”. Better than being fast is making every keystroke count. Get to know your editor.

Patience is a great virtue and you should nourish it. When tackling a problem, the first thing to do is understand it, if you’re working with someone else even better, discuss it, validate your assumptions. When trying to use a library read the documentation first, read the man page, RTFM sounds familiar? When reading, be sure to actually comprehend what is written don’t just scan through pages, you need to really absorb the information, it will save you many hours of debugging and a great deal of frustrations. When you find an error read the back-trace, read the environment variables, don’t just assume you know the problem until you understand the cause. When coding unless you’re just trying something out, think about the ways you want the code to be used, think of your interface before your implementation. This is one of the best outcomes of doing TDD, so even if you’re not doing TDD/BDD/ADD or whatever flavor you prefer at least think from the outside, you will soon realize you need some tests.

Being conscious let’s you see the obstacles in front of you, so you can avoid them or just defer them until you’re better prepared. Be able to recognize when you’re stuck and back away.

And last but not least take pauses every so often, rest your eyes and your brain, take a deep breath, relax and you’ll be back into action with more energy.

Being pragmatic

2011-12-21T00:00:00-04:00

It is perhaps my experience but I’ve hardly had the opportunity to work on green field projects, but rather worked on legacy ones where most of the original developers were no longer part of the team or even none of them. Projects with little to no documentation and in some cases no tests at all. You probable know this feeling, it sucks, you want to do things but everything you touch breaks something else, where you obviously see that there was lack of care. The point is not to criticize the developers who did this, they probably didn’t know any better and they probably tried to do their best given the constraints they had. But being the one who cleans that mess is not cool. So what can you do? Well don’t be that developer. Take care of your future self and others who may come after you and make it easier for them. Others will probably curse you anyway, you just can’t be perfect, but at least try to be invisible, try to give your best shot and don’t cut corners. Test your code and think from the outside, how the code is going to be used. May be you’re thinking that your boss is going to tell you to “not waste time” with tests or “just make things work”, and this is the point where you have to keep true to yourself and be a professional. You have to be ethic and do things well, but you also have to choose your battles right, not everything is a matter of life and death but also not everything is unimportant, choose right and you’ll earn the confidence of your peers and superiors.

Sometimes a big refactoring is too much to tackle at the moment, then try to contain the mess, don’t add more to it if you can avoid it, resist the urge to go and rewrite it all. Sometimes parts of an application are not pretty, but they’re stable and you hardly have to modify them, don’t change a lot of code just to make it “better”. In other occassions you don’t like the “style” of the code, adapt to it, other people probably don’t like your “style” either. Sometimes a refactoring seems like the only choice, then go ahead but don’t underestimate the ones before you, as you may find some surprises in your way. Be patient, with time you will learn the parts of the application that are always changing and are hard to mantain and then you’ll have enough experience to do a proper refactoring, if you rewrite everything you don’t like then you’ll never learn why you don’t like it.

Back from the trenches

2011-08-29T00:00:00-04:00

It’s been some agitated months lately for me, I quitted working at JustLanded after almost two years there and then went working for some consulting, the experience was not so great, actually it was really bad, the kind of experience that has made me learn to choose very carefully my future career moves and never again believe in marketing people. Fortunately I got an offer to work at XING offices in Barcelona, so I packed my stuff and moved there. Now this is a really good place to work, everything was as we talked, they’ve been very helpful with my relocation and the environment is great, lots of smart people that want to do a good job, so nowadays I’m very happy and enjoying my new city.

Since moving to Barcelona I’ve been keeping myself very busy contributing to some open source projects as Rubinius, Rinari and lost of elisp stuff and it’s been awesome. I’ve also released a new project called filet, which is a DSL to write acceptance tests on top of Test::Unit, with some nice extra features, but that will be subject of a future post.

Also since I started working at XING they got me a MacBook Pro, so it was a big switch for me since I’ve been using Ubuntu for years. After a couple of months I can say I’m really used to the new OS, though I still use Ubuntu every now and then, but getting there was not always easy. The first thing I missed was a package manager a la APT, the lesson learned is that if you value your sanity you will just uninstall macports and use homebrew. Another thing I was missing was maximizing windows, for that there is a tool RightZoom that makes them actually maximize. I also struggled a bit to get emacs and my configurations working, since I didn’t wanted to stay on emacs 22 which ships by default with OSX. I tried Aquamacs, Carbon Emacs, etc and finally settled for the package at http://emacsformacosx.com/.

So it took me a while to write this post, I’ve been procrastinating it for far too long, so now I hope I can go back to publishing on a more regular basis.

Avoid Empty Deploys with Capistrano

2011-01-13T00:00:00-04:00

If you’ve ever forgotten to push your changes to the remote repository before trying to make a deploy, you will know that it can be really frustrating to think that everything has gone live when actually it has not. This little script will help you avoid this situations.

  namespace :deploy do
    task :check_changes do
      if current_revision == real_revision
        Capistrano::CLI.ui.say("You don't have any changes to deploy")

        agree = Capistrano::CLI.ui.agree("Continue (Yes, [No]) ") do |q|
          q.default = 'n'
        end

        exit unless agree
      else
        # current_revision depends on current_path
        reset!(:current_path)
        reset!(:current_revision)
        reset!(:real_revision)
      end
    end
  end

What this does is check that we have different revisions deployed between our deployed version and the version in repositories and it will ask for confirmation in case they are the same. Just include the above code in your deploy recipe and then for the environment you want to deploy to just include the following:

  before "deploy:update_code", "deploy:check_changes"

If you’re doing any kind of automated deployment, let’s say from you continuous integration server to your staging server don’t include that code since it will sometimes just wait for an answer that is never going to come.

Hope this helps you and happy deployments!

Passenger, RVM gemsets and Bundler

2010-11-17T00:00:00-04:00

When using passenger with rvm I’ve had some issues with project specific gemsets, where bundler was unable to find the gems. After searching a lot I found out about using the “config/setup_load_paths.rb” file to tell passenger where to locate your gems, but then I had a new issue with rvm trying to use the system ruby instead of the ruby version of my .rvmrc file.

After going to the irc channel, I got some help that help me fixed my problem. The culprit was my rvmrc file.

As I’ve seen on many blog posts the file looked something like this:

rvm use --create ree@rails235

The solution was to generate the rvmrc file using rvm itself like this:

rvm --create --rvmrc use ree@rails235

The file contents now look like this:

if [[ -d "${rvm_path:-$HOME/.rvm}/environments" \
  && -s "${rvm_path:-$HOME/.rvm}/environments/ree-1.8.7-2010.02@rails235" ]] ; then
  \. "${rvm_path:-$HOME/.rvm}/environments/ree-1.8.7-2010.02@rails235"
else
  rvm --create use  "ree-1.8.7-2010.02@rails235"
fi

And passenger is able to find my gems without any problems.

Hope this helps you as I spent way too much time with this issue.

Conferencia Rails Workshop

2010-11-04T00:00:00-04:00

As promised here are the slides for the “Conferencia Rails” workshop on process automation. Thanks to all the people that were there. I’m also releasing the redmine CLI I’ve created along with the CLI twitter client.

The presentation was created using the slideshow gem which generates an html document for you.

Slides To start the presentation just hit the “LEFT” arrow key. You can also find a pdf version here.

Redmine CLI

Ruby CLI Tweet

Hope you enjoy it.

Ruby Enterprise, Passenger and Encoding hell

2010-05-25T00:00:00-04:00

Today I spent several hours with my friend Gleb trying to find a weird bug we we’re having importing some rss feeds.

We have a rake task that will grab an xml feed and import it to our system. When we call this rake task from the command line it would run fine, but if we run it from inside our application, we would get some wrong characters (you know, the usual ???) in the imported items.

After trying a million ways to get this to work, we found that the problem is that Passenger doesn’t pass the environment variables to the application processes, so our import task wouldn’t know about our LANG variable. We have this set to LANG=en_us.UTF8 but our process would not see it, which would cause ruby to not use utf8 for the strings.

The solution was pretty straight forward, just pass the LANG variable when calling the rake task, finding the solution not so straight forward and definitely not fun. The sad part is that this is a known issue with passenger since 2008 and this is the second time it gets me (If you’ve tried to use an oracle db you know what I’m talking about). If you need more information about this you can check it here.

Emacs support for Jekyll

2010-04-11T00:00:00-04:00

If you’re using emacs to write your jekyll blog posts, there is a mode to help you with some common tasks. It is originally from metajack. Recently I thought it could be a nice addition to have syntax highlight support for jekyll posts, so I got my hands dirty and after some hours of lisp hacking (this was my first attempt at lisp programming) it was a reallity. It is based on nxhtml so you need it to work.

Here is an screenshot of it at work:

You can get it here.

Setting environment to run migrations with capistrano ext

2010-03-09T00:00:00-04:00

If you’re using capistrano-ext to deploy to a different server, using a custom environment, you’ve probably noticed that it always tries to run the migrations for the production environment, like this:

cd path_to_app/deploy/releases/20100309152738; rake RAILS_ENV=production  db:migrate

Digging through capistrano’s source I found the solution is really simple, just set the rails_env variable to the environment you want, in this example staging. So inside config/deploy/staging.rb

set :rails_env, "staging"

Then when migrations get executed they’ll have RAILS_ENV=staging.

Monthly archives for Jekyll

2010-03-08T00:00:00-04:00

Recently I moved my blog to Jekyll, while being able to write stuff directly in my favorite editor EMACS, there was some functionality that I was missing from my previous custom blog engine, such as archives. Looking at how I could achieve this, I found Raoul Felix approach to the problem. Instead of patching jekyll, he wrote a small library that wraps around it, called jekyll_ext. Using it was really easy, and based on some of the extensions he created, I was able to provide this functionality in my site.

Although I had archives generated for me, I was still missing a way to display this information on my site, so I decided to create my own extension.

I added the following code inside _extensions/archive_iterator.rb, which will provide me with an array of all the months when I’ve written posts:

module Jekyll
  AOP.around(Site, :site_payload) do |site_instance, args, proceed, abort|
    monthly_archives = []

    site_instance.collated.each do |year, hash|
      hash.each do |month, days|
        monthly_archives << {
          'name'  => "#{Date::MONTHNAMES[month]} #{year}",
          'url'   => "#{year}/#{month}",
          'posts' => days.values.flatten
        }
      end
    end

    result = proceed.call
    result['site']['monthly_archives'] = monthly_archives
    result
  end
end

The information for the archive was gathered from the archive_gen extension, although I had to slightly modify. Instead of processing the information after render, I had to do it before rendering, so the information would be available when the pages are created, like this:

AOP.before(Site, :render) do |site_instance, result, args|
  site_instance.posts.reverse.each do |post|
    y, m, d = post.date.year, post.date.month, post.date.day
    unless site_instance.collated.key? y
      site_instance.collated[ y ] = {}
    end
    unless site_instance.collated[y].key? m
      site_instance.collated[ y ][ m ] = {}
    end
    unless site_instance.collated[ y ][ m ].key? d
      site_instance.collated[ y ][ m ][ d ] = []
    end
    site_instance.collated[ y ][ m ][ d ] += [ post ]
  end
end

Then inside my layout I was able to easily display this information like this:

<ul>
  { % for monthly_archive in site.monthly_archives reversed % }
  <li>
    <a href="/"></a> (0 posts)
  </li>
  { % endfor % }
</ul>

Note the extra space between ‘{‘ and ‘%’, this is to avoid liquid interpreting the code inside the tags. You can view all the source code here.

View your emails with cucumber

2010-03-02T00:00:00-04:00

I’ve been developing some new mailers at work, and I’ve found it really helpful to be able to view the emails as they are sent to the users. So I’ve implemented a cucumber step to help me achieve that, inspired on a similar webrat step for web pages.

Inside a support file for cucumber, like features/support/open_email.rb, insert the following code:

module SaveAndOpenEmail
  include Webrat::SaveAndOpenPage
  def save_and_open_email(email)
    return unless File.exist?(saved_page_dir)
 
    filename = "#{saved_page_dir}/email-#{Time.now.to_i}.html"
 
    File.open(filename, "w") do |f|
      f.write email.to_s
    end
 
    open_in_browser(filename)
  end 
end
 
World(SaveAndOpenEmail)

Then in your step definitions, you can implement a step like this

Then(/^show me the emails?$/) do
  save_and_open_email(current_email)
end

UPDATE: As of version 0.2.2 of pickle, they already include this functionality, although it has a bug which has not been fixed. If you try to call that step, you will see:

undefined method `open_in_browser' for #<Cucumber::Rails::World:0x..fdb4951fa> (NoMethodError)

To fix it, as a workaround do this in features/support/email.rb

require 'pickle/email'

Pickle::Email.module_eval do
  include Webrat::SaveAndOpenPage
end

ActiveRecord migrations from the console

2010-02-23T00:00:00-04:00

If you ever run into the situation where one migration doesn’t complete sucessfully, and you’re stuck with a column in a table or a new table, so you can’t drop the migration or execute the migration again, you can always call the migration methods from the console like this:

ActiveRecord::Migration.drop_table :table_name
ActiveRecord::Migration.remove_column :table_name, :column_name

Hopefully this will help you when you’re developing your migrations.

IE issues with new Element and class with Prototype

2009-08-12T00:00:00-04:00

The problem we have is that this code

new Element('div', {'class':'klassName'})

will work in firefox but in IE (tested on version 8) the className is never set, which was causing some problems with the elements styles.

One of the workarounds would be to explicitly add the class name, like this:

var e = new Element('div');
e.addClassName('klassName');

The problem with this approach is that at work, we have a huge javascript codebase, so instead, we are going to monkey patch Prototype. We’re working against version 1.6.0.3 of prototype, that’s why we add the alert, so when we update, we’ll catch this and check if it was fixed on core.

// This is a dirty hack to protoype, so IE, will take class names on new Element
// new Element('div', {'class':'klassName'}) doesn't work on IE but does on firefox
// in IE, we wouldn't get the className set.

if (Prototype.Version != '1.6.0.3') alert("BEWARE OF THE PROTOTYPE VERSION");

(function() {
   var element = this.Element;
   this.Element = function(tagName, attributes) {
     attributes = attributes || { };
     tagName = tagName.toLowerCase();
     var cache = Element.cache;
     if (Prototype.Browser.IE && (attributes.name || attributes['class'])) {
       tagName = '<' + tagName + ' name="' + attributes.name + '"' + 'class="' + attributes['class'] + '"' + '>';
       delete attributes.name;

       return Element.writeAttribute(document.createElement(tagName), attributes);
     }
     if (!cache[tagName]) cache[tagName] = Element.extend(document.createElement(tagName));
     return Element.writeAttribute(cache[tagName].cloneNode(false), attributes);
   };
   Object.extend(this.Element, element || { });
   if (element) this.Element.prototype = element.prototype;
 }).call(window);

Git Goodies

2009-02-12T00:00:00-04:00

A couple days ago I had to gather some information from a git repository, so I’m sharing this small scripts with you.

List of all authors on a git repo:

git log --pretty=short | grep Author: | awk '{print $2}' | sort | uniq

List all modified files since a revision:

git-whatchanged revision.. --pretty=oneline | grep '^:' | awk '{print $6}' | sort | uniq

Will Paginate And Ajax

2008-12-16T00:00:00-04:00

I recently had to implement some ajax pagination for a site. After googling for a while I found a solution, but I couldn’t customize the pagination url’s or I had to specify the paginator to use (will paginate’s default or mine for ajax), so I came up with this solution which fulfils all my needs.

First create the following class in your app/helpers.

class RemoteLinkRenderer < WillPaginate::LinkRenderer
  def prepare(collection, options, template)
    @remote = options.delete(:remote)
    super
  end

  protected
  def page_link(page, text, attributes = {})
    if @remote
      @template.link_to_remote(text, {:url => url_for(page), :method => :get}.
                               merge(@remote), attributes)
    else
      @template.link_to(text, url_for(page), attributes)
    end
  end
end

Then you have to tell will_paginate which link_renderer to use, I do this in a rails initializer.

WillPaginate::ViewHelpers.pagination_options[:renderer] = 'RemoteLinkRenderer'

So with this solution, you can work like you would normally with will_paginate, but if you need to do an ajax link, then you’ll have to pass the options in the remote hash, something like this:

will_paginate(@comments, :remote => {:update => 'comments'})

That’s it enjoy. You can keep passing the same options you would normally do to will_paginate to customize the behaviour.

Will Paginate And Merb

2008-12-09T00:00:00-04:00

I read something about how to do it in this post by The merbist, albeit the information was not complete.
So here are my instructions:

Clone mislav’s will_paginate repo and build the gem from the agnostic branch.

git clone git://github.com/mislav/will_paginate.git
cd will_paginate/
git checkout origin/agnostic 
gem build

With this commands you’ve generated the will_paginate-3.0.0.gem.

If you want to install it system-wide use your usual gem install.
If you want to bundle it in your project, as I did, then you’ll have to do:

thor merb:gem:install path/to/gem

That’s it.

Mr Dias

Las victorias de los demás

Gratificación Aplazada

63 pensamientos y lecciones que he aprendido en 2 años como manager

Creating jenkins users and tokens programatically

Get to know your editor

Pair programming Dos and Don'ts

Join the Newsletter

Join the Newsletter

Using magit with Github Enterprise

Pair programming revisited

Join the Newsletter

Join the Newsletter

Switch AWS accounts easily using roly

Fast directory navigation using the CDPATH

Blog redesign

Packaging AWS Lambda dependencies using docker

Using docker containers with your existing rails app

Dockerizing our dependencies

Dockerizing the app

Automating our setup with docker compose

The end

Faster docker containers development using fig

Changing to devops

Growing a garden

Barcelona GDG Devfest 2013

Closed doors open source

Git rebasing without conflicts

Using chef to setup your OSX environment

Slow down, you are programming too fast

Being pragmatic

Back from the trenches

Avoid Empty Deploys with Capistrano

Passenger, RVM gemsets and Bundler

Conferencia Rails Workshop

Ruby Enterprise, Passenger and Encoding hell

Emacs support for Jekyll

Setting environment to run migrations with capistrano ext

Monthly archives for Jekyll

View your emails with cucumber

ActiveRecord migrations from the console

IE issues with new Element and class with Prototype

Git Goodies

Will Paginate And Ajax

Will Paginate And Merb