API Notation: A simple way to document your libraries' contracts

When writing specifications and trying to figure out how components will interact, an important part of my workflow is to define the public API as the contract others can depend on: So if we have a complex feature where several people are collaborating, we can ease up the integration woes by properly defining the methods, properties and events they'll be using to communicate. This means that I usually end up having to write APIs in spec files constantly, and over the years I've been using and developing a notation for this.

The API notation is very simple and encodes what public properties, methods and events an object/class provides. It looks like this:

   + class property
   - instance property
  ~> listened events (socket)
  +> listened events (class/module)
  -> listened events (instance)
  <~ dispatched events (socket)
  <+ dispatched events(class/module)
  <- dispatched events (instance)
  :: class method
   # instance method

Other symbols
  => returns
->() callback return
[xx] optional
<xx> data type

Recommended order: class first, then sockets, then instance. Internally: Properties, events, methods.

// Anything after two forward slashes is a comment

That's it. This simple notation lets us quickly define what an object or class looks like, and what data types we can expect from methods, properties and events. It's a notation that's easy to put inside documents, and it's easy to parse. The origin of the symbols is kind of a mixed bag and I've been developing based on some languages I've used. The - and + for properties come from Objective C, and the # and :: for methods come from ruby. The < and > in events define the direction of the flow (outgoing or incoming), and the ~ for socket events is an attempt to simulate the thunderbolt symbol used in network diagrams.

If you find yourself constantly having to write APIs for your components, and would like to have an easy way to add them to your documents (especially plain text / markdown documents), give it a try. You can use syntax highlighting in vim, atom, or sublime text by creating files with the .api extension.

If you do decide to give it a try, let me know how it works out for you and if there's any cases you think it doesn't work with. It's constantly evolving to reflect the types of applications I've had to create, so any other cases that may help to get this further are welcome.

↑ Go to top of article

Fluorine: the library to get things flowing

Today I was happily surprised with the fact that fluorine has been made publicly available with an MIT License! This is a library created by azendal as a way to solve some of the more complex flows in breezi. The problem had been bugging us for a while and the several existing solutions to the async problem didn't feel right for it, and then fluorine arrived to the neon family of libraries.

Fluorine is a really simple flow abstraction for javascript that doesn't do much: You can have a Flow, which has a series Steps; a step has a name, a list of dependencies, and a fulfill function. The way it works is that flows run automatically, and every step that can be taken is taken, then its dependents are executed, and so on until all nodes are fulfilled. That's all there is to it, and that's all it needs to provide powerful asynchronous constructs that can stay decoupled.

But let's code a simple example:

In the following example we're loading an application where we allow our user to view a 3D model of their favorite 1985 vintage action figures in a fake shelf. We show a loading screen while we get the data for the models, then fetch the models themselves, also request the user data (so we can see their favorites), plus all the latest posts from the most popular social network for enthusiasts of 1985 vintage action figures — G.I. Yo. Once we have the model and user data, we can display the shelf so the user can see the name of 1985 snowman and finally settle that argument with joe about which 1985 vintage action figure is the best 1985 vintage action figure, so we have to: hide the loading scren, show the models with a generic image and leave a loader in the social network box. Once the models are fetched, we can start displaying them in the shelf instead of the generic image while it loaded; once we have the social networks, we put the posts in there. So, that's easy right?, no chance of turning this into a mess...

A boring old diagram 34 indentations later...

I put this in a diagram with handy color coded arrows so we don't get lost. Now we know what operations depend on each other, and that's all we need for fluorine. So, we can now turn that diagram into a flow:

    var giFlow = new Flow();

    // Top Row Nodes (as shown in the diagram)

    giFlow.step('showLoadingScreen')(function (step) {

    giFlow.step('fetchUserData')(function (step) {
      UserData.fetch(function (userData) {

    giFlow.step('fetchModelData')(function (step) {
      ModelData.fetch(function (modelData) {

    giFlow.step('fetchSocialData')(function (step) {
      SocialData.fetch(function (socialData) {

    // Middle Row Nodes (as shown in the diagram)

    giFlow.step('hideLoadingScreen').dependsOn('showLoadingScreen', 'fetchUserData', 'fetchModelData')(function (step) {

    giFlow.step('displayPlaceholderSocialBox').dependsOn('fetchUserData', 'fetchModelData')(function (step) {
      socialBox.display(function () {

    giFlow.step('displayModelShelf').dependsOn('fetchUserData', 'fetchModelData')(function (step) {
      modelShelf.display(step.data.fetchUserData, step.data.fetchModelData, function () {

    giFlow.step('fetchModels').dependsOn('fetchModelData')(function (step) {
      Model.fetch(step.data.fetchModelData, function () {

    // Bottom Row Nodes (as shown in the diagram)

    giFlow.step('fillInGIYoPosts').dependsOn('fetchSocialData', 'displayPlaceholderSocialBox')(function (step) {
      socialBox.fillInGIYOPosts(step.data.fetchSocialData, function () {

    giFlow.step('replaceModels').dependsOn('fetchModels', 'displayModelShelf')(function (step) {
      modelShelf.replaceModels(step.data.fetchModels, function () {

That's all there is to fluorine: you define steps, you fulfill them. Every step may have dependents, and it can access their data from the callback! Now you can define complex operations step by step, you could create complex branching by not triggering a step's success method. Another important part of fluorine is that modifying flows is really easy, as long as you have clearly defined nodes, you can just move around dependencies to alter the way the program runs! You can even check your work against the spec by converting it to dot format (eg. giFlow.toDot()):

digraph  {
showLoadingScreen -> hideLoadingScreen
fetchUserData -> hideLoadingScreen
fetchModelData -> hideLoadingScreen
fetchUserData -> displayPlaceholderSocialBox
fetchModelData -> displayPlaceholderSocialBox
fetchUserData -> displayModelShelf
fetchModelData -> displayModelShelf
fetchModelData -> fetchModels
fetchSocialData -> fillInGIYoPosts
displayPlaceholderSocialBox -> fillInGIYoPosts
fetchModels -> replaceModels
displayModelShelf -> replaceModels

dot -Tpng that_file_up_there.dot -o fancy_graphic.png

Fancy Graphic

They look the same (ish)! It even did a better job at putting it together!

So that's fluorine, a pretty simple flow tool that can let you build complex stuff, you could implement a neural network, or a behavior tree for a game actor, or a loop of events, or do some complex distributed tasks, you can use it for almost anything as long as you can graph it, because that's all it really is: graphs. You could even create dynamic nodes and have a flow that is created programatically!

I hope that example was enough to get you interested on how you can use it now that it's open to everyone! Have fun :D

↑ Go to top of article

A theme for cows, with two examples!

I've been wanting to create a theme for cows to use anywhere in the game to give familiarity to the music, or contrast against another anti-theme to create musical cues for the player to indicate danger, tension or their opposites in the current situation.

While trying to come up with something fun to play, I landed on a chord progression that had a great calm sound; I wasn't specifically looking to do something for the game, but it just seemed like a good place to try and fit the music from the opening screen. At the top of the post are two samples of the melody used in the bovine fanfare and the cow town theme, they're both very much a work in progress, but illustrate very well the concept of using the same series in different situations, like in Super Mario World. Also, I guess that's cow's theme.

We'll have to come up with a good counter for this one; her theme is western themed so the other one should reflect more the turn-everyone-into-cows kind of genius of Dr Bov, the game's main antagonist. I'll update when anything new happens; I hope you like it; feedback much appreciated.

↑ Go to top of article

From the Journal: Polarity and Cows updates!

I stopped uploading videos of cows development because my computer died a while ago because of water damage, now I'm finally in the land of the living with some gamey updates: Cows and Polarity II are the two games I'm focusing on this year; Polarity II should release sometime this year since it's pretty simple, and Cows should have a one level demo by december.

Polarity II is still being developed with MonoGame and there are now working linux, mac and windows builds (That was the february goal. yay!) The march goal was to get the waves system and the first wave working, but I got sidetracked and didn't get to coding it. I do have some work to show on the wave system though, so here are some blurry pics from the journal.

The difficulty table

That's the difficulty table for polarity; the plan right now is to have a set of 10 waves, each with different sets of enemies; every time you clear the set you start from wave 1 (eg. 11) but with a new difficulty modifier. The table above lists what I thought was reasonable, though I still need to test it out in-game. There are only four factors to modify: Number of enemies, probability to randomly spawn a scout instead of a regular ship, probability to randomly spawn a shooter instead of a regular ship, andHP multiplier.

Trying to define waves

I tried to define which enemies to use in which wave, trying to introduce the specials for later levels. Excuse my drawing skills, but here's a guide: round with three prongs = regular ship; droplet = scout; round with many prongs = heavy; concave top + three prongs = shooter; concave top + many prongs = heavy shooter. There's also a small sketch of the wave screen, which now looks like this:

Polarity wave screen mock Click to open with annotations.

First wave of polarity

I sketched the first wave with a "notation" I improvised and annotated on the side. It's only an idea; I still need to commit it to the big book of levels.


For polarity I also sketched out some ideas for the UI, trying to keep the chain information clear but unobstrusive. I mocked the chain break animation and giffed it with recordit, which by the way, I help build. So check it out. Please. Not yet though, we're in the middle of something.


Cows has had a lot of progress too! For starters we're no longer going to use löve2d, it's an awesome tool and I'm really into lua, but we're doing everything in unity now which will make a lot of things waaay easier. Toily jumped in to help and he and I are going to be working on it throughout the year to try and release a demo with part of the hub and vegetable fields.

The hub

The hub is pretty simple, but it ties all the other areas together. There's Ushi's dojo in the center, there's the milk bar for some hints, the exits to all the levels, and the fruit store which is important now: Every time you enter the hub from another area, your stomach will be emptied, however, there are fruit seeds found in the different areas which allow you to get the transformation from the fruit store and enter any level with any powerup. That way you'll discover new areas to explore by bringing powerups normally unavailable to already visited zones.

Level one overview

The demo of the game will have the first area available; here's an overview of the basic makeup of the level, including the expected route and a quick sketch of how it's distributed. These blocks don't mach 1:1 to a room though. They're just to easily separate the "zones" inside the vegetable fields.


I tried to draw a visual concept for the vegetable fields; I really want it to be a vegetable wasteland with lots of plantish debris, like ramps made out of giant carrots, giant eggplants half-buried in the ground, etc.

Sketch of bovine plains

The first area will be bovine plains: that's a quick sketch trying to figure out the paths and expected behaviors. I don't know what I'm doing. In the bottom is an allocation of space for the maps, we have to fit them all and maintain consistency with their position. That's going to mean a lot of sky tiles to the sides of the sky fortress; It would be a shame if someone hid something there.

That's all the updates I have for now. Toily has a bunch of better drawings, it would be awesome if he could share them as well! *nudge*.

↑ Go to top of article

Introducing Lyricli — Command line lyrics.

I'm the kind of person that enjoys reading lyrics of some songs while I listen to music. I'm also the kind of person that enjoys listening to music with lyrics while working. Also, the kind of person that spends a lot of time inside a terminal. So I decided to do a little lyrics client to use inside a pane of my tmux sessions. I've been using it for a while, but hadn't released it because I never got to writing tests for it.

If you're into music with lyrics in the terminal, give it a spin. The easiest way to install is through rubygems

gem install lyricli

Lyricli uses an engine system that allows it to extract your current song from different places. Since I'm an iTunes+Rdio kind of guy, those are the included ones. Lyricli is usable in the form of the lrc command. To get lyrics for a song you can do it in several ways. The most basic is to call it with the artist and the song as the arguments. For example:

lrc "Of Montreal" "An Eluardian Instance"

The easiest and most useful way though, is by using the included sources. To see what engines are available, call lyricli with the -l or --list-sources. For now it should just display itunes and rdio. You can enable a source by calling lyricli with the -e or --enable flags. For example:

lrc -e rdio

Depending on the source, this will give you certain instructions to enable the source. For example, rdio asks you to authorize the app, displays the URL and an input for the authorization code. Once your engine is set up, you can just call lrc while listening to music, and it will automatically find the lyrics for your current song. (You could just use watch -n 10 lrc and have an auto-updating lyric pane inside tmux or screen.) If you want to disable a source you can call lyricli with the -d or --disable flags, with the source name as parameter. Additionally you can use -r or --reset flags, again with the name of the source to clean up all the stored settings.

That's about it. I hope it's as useful to you as it has been to me. In my laptop I usually have a vim window with a small sidebar where I run lyricli, while at work I use it as a narrow column that sits between vim and two regular zsh windows (yay! screen real estate!) .

Check out the code on github and let me know what you think. If you need a new source, feel free to let me know, if I have a way to I'll do my best to; or you can try creating one yourself. It's really easy, and you can check the included rdio and itunes files to check how it's done.

↑ Go to top of article

Seis meses después: la vida sin facebook.

Ya hace poco más de seis meses que abandoné facebook por completo (bueno, no por completo, tengo una cuenta privada con un solo amigo, pero ese es otro cuento.). Seis meses es bastante tiempo, suficiente para pasar el tumulto del cambio inicial y llegar a una nueva normalidad. ¿Cómo han sido esos seis meses? ¿Fue una buena decisión? ¿Me arrepiento? ¿Estoy interesado en comprar un seguro para mi auto a precios competitivos? La respuesta a todas las preguntas anteriores es: si.

Una interacción social más sana

Creo que uno de los aspectos que ha cambiado más significativamente desde mi auto-ostracismo de facebook es que tengo mucho menos ruido social: en facebook agregar a personas es un contrato de dos lados en el que alguien te pide ser su amigo y otra persona tiene que contestar. El problema es que la interacción es más similar a que un tipo llegue en medio de todos tus amigos, conocidos y familiares y grite "¿Quieres ser mi amigo?", decirle que no se vuelve algo de mala educación, y es asunto público. En facebook tenías dos opciones: o agregas a gente que no quieres, o aceptas tu nueva etiqueta de mamón. El problema se hace más grande si participas en alguna comunidad de algún tipo: como organizador de Temporada de Patos tenía muchos requests de personas de la comunidad que dificilmente conocía, pero terminaría siendo mal visto si no los agregara, todo se mezclaba con mi vida personal, es horrible.

Hoy en día no la sufro tanto, hablo con un diminuto porcentaje de las personas con que hablaba antes pero tengo mejores conversaciones con ellos. Claro que hay dos o tres contactos con los cuales lamento no tener comunicación, pero la mayoría se donde encontrarlos y ellos saben donde encontrarme, si a ambos nos importa lo suficiente: Twitter, Google Talk / G+, Steam, etc. No he perdido a mis amigos, al contrario, he fortalecido relaciones con algunos gracias al hecho de que nuestra relación social ya no es algo que solo está ahí, como todo, en facebook.

¿Pero que alternativas puedes estar usando?

No es mucha diferencia, hoy en día uso mucho twitter para comunicación más casual y de poco significado, la comunidad de videojuegos la veo en steam, y todo lo demás lo tengo en G+ que es lo más cercano a mi sustituto de facebook. Google+ me agrada mucho y pienso que me quita muchos de los problemas de facebook:

  • Agregar amigos es un movimiento unilateral, quitando el estrés de agregar por educación
  • El control sobre que veo y cuando es más claro y efectivo
  • El contenido es mejor (argumentablemente es porque solo cierto tipo de personas están ahí ahora)
  • Hangouts. HANGOUTS!

¿Hay algo que extrañe de facebook? … La verdad si: los grupos con chat + muro. No creo que haya encontrado algo que funcione tan bien en otro lado, pero en el gran esquema de las cosas es algo pequeño para extrañar. Definitivamente no me gustaría volver y cada que veo noticias sobre los males de facebook no puedo evitar pensar: evadí esa bala.

Si me extrañas en facebook, o más probablemente, si quieres regañarme por tomar la decisión de dejar facebook, entonces puedes encontrarme en twitter o en google+ / jabber

↑ Go to top of article

Cuatro tips para ser un buen junkie de la terminal

La terminal es un lugar bonito: todo es más rápido y conciso, puedes hacer más en un comando de lo que puedes hacer en una hora dando clicks, además, siempre te devuelve los libros que le prestas y no se queja si llegas repentinamente a su casa de visita; es casi perfecta. Así sin cambiar nada en cualquier sistema unixoso, ya sea una mac o linux o lo que sea que uses, puedes hacer mucho más de lo que creías que era posible con tan solo abrir una terminal y ponerte a regurgitar comandos.

Lamentablemente no todo es bonito en el mundo de las terminales, oh no. La terminal es una adicción. Empieza de manera inocente: solo la abres para copiar algunas cosas o listar directorios, tal vez un grep de vez en cuando; o, "yo no quería usarla pero me dijeron que arreglaría mis problemas". Todos tenemos historias como esa, todos empezamos así, pero lo inocente pronto va escalando y ya no entras solo por un ls o un cp, ahora estás entrando a tu servidor por ssh; dejaste el grep y ahora usas ack; empiezas a usar tu source control sin GUI. Va empeorando cada vez más: Empiezas a ponerte nervioso cada vez que tienes que salir de la terminal, notas como el mouse no es tu amigo como lo pensabas, le gritas sudo a las personas cuando no quieren pasarte la salsa. Oh, es un problema muy grande y cada vez quieres más y más. Una vez que llegas a este estado no queda más que dejarse llevar, pero cada vez tocas límites más oscuros del internet: empiezas a buscar aplicaciones, tips, one-liners y plugins. ¡ALGUIEN PIENSE EN LOS NIÑOS!

Afortunadamente no tienes que buscar muy lejos, pues tengo aquí un programa de cuatro pasos para hacerte un mejor junkie de la terminal (¿Qué, quién dijo algo sobre curar la adicción... que monstruo haría tal cosa?)

1. Usa vim

vim es una droga bastante particular: ves a los usuarios veteranos y te sorprende la velocidad con la que hacen todo, parecen magos controlando texto; auténticos code-benders. Luego decides intentarlo y te quedas pasmado por aproximadamente quince minutos pensando: "¿Que significa normal? — ¿Dejé el horno prendido? — ¿Como empiezo a escribir? ... ¡creí que era un editor de texto!" y luego lo cerrarás con un gran sentido de confusión solo para reintentarlo cuando el siguiente artículo sobre vim llegue al frontpage de Hacker News. Pero no te rindas:

  1. Es normal sentirse así.
  2. Todo va a mejorar.
  3. Vas a subestimar lo que quiero decir con "Todo va a mejorar".
  4. Code-bending.

Empezar con vim es una experiencia más bien rara porque no estás acostumbrado a usar un editor con esa filosofía, y eso toma práctica; es como aprender un nuevo lenguaje. Mi consejo es el siguiente: avientate un tutorial básico, luego usa vim, luego usa vim, luego usa vim y luego por dios y todo lo sagrado usa vim. Los comandos tienen que grabarse en tu memoria muscular y la mejor forma de hacerlo es usandolos una y otra vez. Guarda un cheat sheet y consultalo cuando no sepas que hacer y sigue trabajandolo. — Ah, si, una recomendación que puede no ser muy popular en algunos círculos es que no instales plugins cuando estés empezando: aprender a usar lo que el editor solo te ofrece te ayudará a conocer más el núcleo y te hará rápido sin hacerte dependiente en una serie de add-ons que pueden o no existir en el vim de tu abuelita (si, tu abuelita lo usa y es muy buena con él, pero no instala plugins — bueno, solo CtrlP)

Es común que durante tus primeros hits de vim quieras dejarlo y volver al abrazo cálido y familiar de tu editor de costumbre. No. Lo. Hagas. Sigue editando hasta que te sangren los dedos y obligate a usarlo hata que te sientas cómodo: Una vez que superes la barrera inicial, irás haciendote más rápido, más rápido, hasta el grado en que te empieza a molestar no tener los controles de vim en los clientes de correo, en los <textarea> y en los cuadernos de composición.

Un tutorial recomendado es vimtutor: corriendo ese comando en la terminal, podrás seguir un útil tutorial guiado usando el mismo editor. Puedes complementarlo con uno de tantos Cheat Sheets.

2. Usa tmux

¿Qué es mejor que una terminal? ¡Muchas terminales!. Cantidades enormes de terminales entre las que te puedes mover con el teclado. tmux o terminal multiplexer es una aplicación que te ayuda a partir tus sesiones de terminal en pestañas y páneles para particionar tu pantalla y organizar mejor tus diferentes terminales. ¿Cuál es el beneficio? Pues todo depende de para que lo uses; en mi caso: Puedo poner vim en la mitad izquierda de la pantalla y dos sesiones de zsh en la otra mitad, una arriba de la otra; en la de arriba puedo correr comandos como ack y tree, o hacer operaciones en el disco; en el otro puedo tener el servidor de rails, un irb o algun log con less o tail; cuando tengo el monitor extra conectado puedo poner una columna con la letra de la canción que estoy escuchando en rdio; también podría tener vim y zsh en una pestaña, irb, rails s o mongo en otro; o puedo tener un proyecto de rails en un tab, cada rack engine que esté usando en otro y el server de staging en ssh en otro... htop en bla bla bla bla bla bla ... De verdad cambia como organizas tu trabajo.

La otra cosa que hace muy bien es permitirte despegarte de una sesión para reconectarte luego. Puedes abrir una sesión de tmux para un proyecto, y cuando ya quieras olvidarte de el simplemente te despegas de la sesión y vuelves a tu terminal normal o empiezas a trabajar en otro proyecto. Cuando quieras volver a el, solo vuelves a pegarte a la sesión y de nuevo estarán tus ventanas como las habías dejado. Es bastante sorprendente el cambio que hace poder "entrar y salir" de contextos: cuando vuelves a la posición de un proyecto anterior, es como si tu cerebro se cambiara de modo al mismo en que estabas cuando lo dejaste. Incluso puedes cerrar la terminal y seguirán ahí (solo no apagues la computadora, para eso hay que seguir leyendo)

Además, te hace ver interesante.

Si quieres configurar mejor tu tmux y aprender algo sobre que puede hacer, recomiendo esta guía en dos partes.

Extra hit: tmuxinator

Si empiezas a usar tmux y quieres tener más control sobre como empezar proyectos y que hacer en caso de que apagues la computadora y se mueran tus sesiones, entonces necesitas tmuxinator: una gema de ruby que te permite definir tus pestañas, páneles y los comandos que correrá cada uno en un conveniente archivo de yaml que se usará para generar tu ambiente cada vez que tenga que reiniciar la sesión.

3. Sincroniza tus dotfiles

Llega un punto en la vida de todo junkie en la cual tiene que usar una computadora nueva, prestada o robada. Ach! Terrible. Después de todo el tiempo que invertiste configurando tu prompt, tus opciones de ack, tu configuración de vim, tu profile de bash o zsh; solo para perderlo todo. Llegas a un triste prompt blanco y vacío y tienes tres opciones: a) re-configuras todo hasta un modo aceptable, b) usar la terminal en modo vainilla, o c) pasar tus archivos de configuración de una maquina a otra.

Obviamente, la razón más sana es c), pero cargar los archivos es una molestia y además, ¿Qué pasa si luego modificas una en otra maquina? o ¿Qué pasa si tienes que usar la terminal remota de un hermitaño que no te permite conectar dispositivos físicos? ... Si tan solo git hubiera git algo git que haga git el manejo git de versiones de archivos de texto giiiiit de una manera giiiiiiiit distribuida y que además sea fácil giiiiiiiiiiiiiiiit de giiiiiiiiiiiiiiiiiiiiiit....


Puedes crear un directorio .dotfiles en tu directorio base y hacer un repo de git ahí y meter todos tus "dotfiles" como .bash_profile o .ackrc o todo el directorio .vim. Luego solo es cuestión de hacer links a su lugar original y ahora podrás clonar tu repo y reaplicar tus configuraciones en cualquier maquina que tenga git. ¿Y si no tiene git? ¿Por qué no lo tiene? ¿Por qué la estas usando? ¿De quién es? ¿Quién podría estar a la puerta a estas horas? ¿Acaso es el dueño de la computadora? Ahora si que estás en problemas.

Si tienes dudas, puedes consultar esta buena guía para tener tus dotfiles sincronizados en "la nuuuubeeeeee" (agregue un efecto de arcoiris).

4. Usa zsh

bash es una buena terminal y ha sido mi amiga desde hace años: hemos vivido tantas cosas juntos que se podría decir que nuestra relación es tal que solo una persona superficial la dejaría. Pues soy superficial, y la dejé. Por algo mejor: zsh.

¡Blasfemia! ¿Qué podría tener de mejor zsh? Una lista de mis features favoritos:

  • Autocomplete en los parametros de comandos (e.g. con kill te muestra una lista de procesos y con git te muestra los comandos como checkout, merge, etc.)
  • Autocompletado interno de paths (e.g. /Us/be/Do/pr/m + tab => /Users/benbeltran/Documents/projects/my-project.)
  • Historial compartido.
  • Correción de errores (e.g. si escribes vmi, te preguntará si no quieres decir vim :)
  • Poder navegar con las flechas cuando aparecen las opciones para tab completion
  • Globbing avanzado que te permite hacer operaciones avanzadas como seleccionar solo los symlinks de un subdirectorio, o solo los directorios que tengan cierto patrón. * Muchos, muchos plugins.

La mejor forma de disfrutar zsh es utilizando oh-my-zsh: una forma sencilla de instalar zsh con una buena cantidad de plugins, temas y configuraciones que te harán la vida más fácil. Yo personalmente uso una versión modificada del tema "prose", pero hay mucha variedad para elegir.

Espero que haya sido de utilidad para esos junkies que estan buscando que más pueden hacer con su terminal, y espero que caigan más y más en el vicio. Si quieres regañarme o exigirme pago por algún destrozo que haya causado en tu casa, o si le molesta que lo tutee, puede encontrarme en twitter o por correo / jabber.

↑ Go to top of article

Hola Jekyll

Quien tiene tiempo de administrar un servidor con wordpress hoy en día. Nadie, eso es quien. Y por nadie quiero decir "yo no". Y por "Quien tiene tiempo de administrar un servidor con wordpress" quiero decir "Quien tiene la motivación de actualizar un blog pero no quiere sentir que está gastando dinero en este dominio en vano".

Por eso, ahora n, s o vocal cambia de formato a un blog de Jekyll. Lo cual es lindo porque puedo escribir todos mis posts en markdown y solo tengo que dar push para cambiar el sitio, sin mencionar que todo es estático. Pero no se preocupen, todos sus personajes favoritos están de vuelta, incluyendo al favorito de los fans "Felipe, el Mono de los Updates"

Como siempre, hay partes del sitio en español, otras partes en inglés. Mantiene las cosas interesantes.

Bueno, como ahora hay más proyectos, esperen al menos escuchar algo sobre eso. Creo. Gracias y muy buenas noches. Por el momento les dejo algunos lugares donde pueden encontrarme.

↑ Go to top of article