Archivo de la categoría: Language: EN

Friction powered Longboard

This is a redesign of the Rotor Flettner project. The effect works after testing it mounted on a windsurf board but it has a potential flaw: Magnus effect has a smaller force than the wind pulling you to the side. The result is that you go more in the wind direction than in the direction that you really want to go. The equivalent to having a very small sail.

But anyways it was a lot of fun to make it and having already the engine and the structure to mount it I thought, why not to try doing something with it :)

And it works, went about 2 kilometers back and forth after discovering I made some design errors and that friction is not my friend. Engineering lessons learnt:
1.- Control cables of the engine should not be touching the floor
2.- Engine should transmit power using some similar material as the wheel
3.- Friction generates heat and 50% of the battery or more is wasted (maybe good for the winter)

Skate and position detail

Wheel coupling with engine

Anderson.Paak dances with us in Berlin

Great concert in Lido with Herr Paak.

Only bad detail: The sound in LIDO. I know that in small shows is almost impossible to have a great acoustic. But I heard Robert Glasper in Festsaal Kreuzberg 2 years ago, and it was just awesome sound. Leaving out the differences, since Festsaal was 90% wood, and thus a great acoustic natural place this time the sound people at Lido did a poor job. Or just the sound system is not prepared for a show like this. Could hear his voice almost always in the background, without a different output channel and always mixed with the bass and the percussion.

Anyways a great performer with a cool band, great DJ and a highly recommendable show. Proud to be dancing with you Brandon!

Learning DOCKER #1

Docker ship with containers

Docker is an exciting technology since April 2013 when it started as open source project. But is only since last year or so that I started hearing more and more about it. And it’s mostly because some companies like Zalando (Berlin) , Spotify and Netflix started implementing it successfully in their servers.

The Docker Mantra is the following :

Build, Ship, Run

Any App, anywhere!


I’ve started trying in my Ubuntu 14 machine with this tutorial:

And what I will try to accomplish in the next entries after playing around with it, is to instance some basic WebServer dingie with some simple API, or just Apache+PHP 7+Symfony. Keep tuned!

Some interesting links: Supercharge your environment using Docker (Presentation)

New project: Portable Flettner-Rotor (Longboard)

3D model available on

The idea come while reading “Symmetry of Sailing” by Ross Garret. The german engineer Anton Flettner was the first to use this physical principle as propulsion engine for a ship in 1922.

The still difficult part and open points to discuss that I have in this Winter project are:

  • Material to use in the main structure. The goal is that is light, when possible less than 10 Kilos,  but resistant since it needs to provide lift.
  • Motor weight: 170 g  Speed controller: 230 g  . Cables + Battery: Aprox.  2 K. Making a total of 2.5 Kilos weight.
  • Still open to discuss: At what speed needs the cilinder to roll and what would be the ideal diameter to provide enough momentum to move 70 Kg in a Longboard (I thought about 40 cm diameter).
    The chain relation between the motor and the cilinder to have the right speed and force. Ex: 10 spin motor: 1 spin cilinder
  • And to end the question: What kind of lift will this generate on a 10 Knots wind, coming from the optimal point, let’s say 90 degrees left or right from the cilinder.

The evolution of a sponsored Tweet

Mini-post with a tweet advertising test made 5 Nov. 2015 at 13:45.

Budget: 9,20 € ( 10 dollars is the minimun budget )

At the end of the day what it delivered is this:

696 organisch / 11.177 gesponsert
Interaktionen insgesamt
79 organisch


Medieninteraktionen 416
Detailerweiterungen 145
Profilklicks 60
„Gefällt mir“-Angaben 8
Retweets 7
Link-Klicks 7
Hashtag-Klicks 2
Folgt 1

I think that it can be a great way to make branding campaigns and to get visibility for a new product or startup.

Positive Groove playlist 1

At the start of this year I got tired of Spotify advertising and I got a premium account. So I started making public playlists and sharing with the friends at work and posting it sometimes the new editions in Facebook and Twitter.  This generated some good feedback so I though about sharing some of them here too.

The idea is to make list with fresh groovy music. Positive, vibrant, soulful and sexy.

Here are some of my favorites:

pg_bamboos“The Wilhelm scream” fromThe Bamboos opens the playlist. They have proven that they are more than meets the eye; over five acclaimed albums, their evolution in sound and style has consistently confounded and exceeded expectations.

“Nothing prepared me for just how fresh and vibrant the music of The Bamboos is” – Notion Magazine (U.K)



pg_metropolitan_jazzMetropolitan Jazz Affair is France based Jazz band  featuring Mr Day, Rongetz, Benjamin Devigne, Patchworks. They have really awesome tunes, if you like nu-jazz check them out.



wolf_myer Wolf is the head of Myer Orchestra, coming from Linz, he worked as manager for companies like Sony Music Austria and played more than 500 live shows as a session drummer in the last six years.



pg_roberto_fonsecaRoberto Fonseca was born in La Havana. Pianist, composer, arreglista and professor of piano’s inclination to music begun at age four with his interest in percussion instruments.
In this playlist we feature “El soñador esta cansado” an awesome track with a heart-taking piano performance.

Good architecture and why not to render Controllers inside Views

In Symfony, Zend and other frameworks you can rend a controller inside a view like this:

{{ render(controller('AcmeArticleBundle:Article:recentArticles', { 'max': 3 })) }}

 Creating and Using templates documentation here.

Just because there is a possibility to render(ControllerMethod,{ params}) in a template doesn’t mean you have to use it.

Doing so leads almost always to a shitty architecture, the turning point where projects start to be hard to debug, since you are mixing a VIEW (Presentation layer) with a CONTROLLER, that in turn renders another VIEW. You get the point.

What happens afterwars is a little bit counter-productive when debugging:
An error in the ControllerMethod is rendered as a template View error.   Not so nice isn’t it ?

Controller methods should Return a View that has all the required parameters to render the View. But if inside that View, you are going around the loop, rendering another Controller that in turn has another View, can be the start of a infinite loop that swallows the universe and you should get a warning red light in your Frontal Lobe. Overcomplicating things with quick and dirty solutions is the wrong way in Software architecture and the responsible of a big amount of relationship problems.

I vouch for strong architecture in software projects

This cheap solutions, like using this render commodities, lead to the start of the bad. And I suggest to avoid it as much as you can unless there is no other possible way.  And certainly there is!

That is the reason to use MVC. To separate Code from Presentation layer, start mixing both, and your architecture will leak.

Symfony Bundles that come always handy for Admin Panels

After a quite accidental start with the Framework I’m enjoying a lot developing stuff with their Form component.
Using bootstrap and almost without any front-end javascript one can build great Admin-dashboard forms, using only a :
{{ form_start(form) }}
{{ form_end(form) }}

Where you want the form to be rendered in the twig template.

As one of my jobs is building friendly Admin Panels, I started to realize that apart of some custom tailored-made solutions, frecuently there is a ground base that works for almost any CMS or CRUD (CReate, Update , Delete manager)

So instead of googling and fetching them one by one, you can find them, or comment them in this post:

  1. TinymceBundle
    Great one.  After installing it, you have a ready made
    {{ tinymce_init() }}
    to put at the end of your twig template. All what you need to do is adjust the config and add a “tinymce” class in your FormTypes.
    Alone with that you can build a CMS in some minutes.
    How cool is that ?
  2. KnpPaginatorBundle
    Whenever we list stuff and becomes large, we need to paginate. This one comes really handy. And like almost all the KNP bundles, is a really nice piece of code, and developer friendly.
  3. Bootstrap-bundle
    Bootstrap is the state of the art front-end to deploy Admin Dashboards.  I had a little fight before making this one work in my Linux dev machine, but is just because I’m not a very front-end guy at the moment, and didn’t had this CSS tools to compile things.  Actually you don’t need this if you want bootstrap base, but I though that having it in a Bundle and thus, being able to install it by composer was a cool thing. And it is!

And that’s basically the 3 things I mostly use all the time.
There are hundreds more, but the basic, ground structur is there.  Making a login / password with FOS User Bundle is also very easy.

In the beginning, the first 2 months or so I was looking towards something that creates an Automatic CRUD manager from a mysql table. After learning more Symfony, I realized that you don’t really need something like that, when it’s quite easy to create your Entities from an existing mysql DB and after that make some Form types and base templates. Cannot get more simplified!
Of course will take some effort, but at the end, you have a custom tailored panel with validation at the top where you can add the customization on top to make your Dashboard more usable.
Hopefully you will make your client happier as well.

Composer lines to add this:

require: {
"stfalcon/tinymce-bundle": "dev-master",
"knplabs/knp-paginator-bundle": "dev-master",
"braincrafted/bootstrap-bundle": "~2.0",
"twbs/bootstrap": "3.0.*",
"jquery/jquery":  "2.1.3"

Symfony2 Best Practices resume

Today I come across this Best practices in Symfony PDF:

And I though about my own practices and where to apply some of this seen in the Best practices book.

Here is a brief 3 points summary of things I would like to change in my next projects:

  1. Using Constant instead of variables in parameters.yml for those settings that rarely (or never) change
    // src/AppBundle/Entity/Post.php

    namespace AppBundle\Entity;
    class Post {
    const NUM_ITEMS = 10;

    As pointed  in the book, doing so, the benefit is that you can access this constant from almost anywhere in your application. Including your twig templates. This is exactly the part I was not aware of:
    // src/AppBundle/Resources/views/Controller/mytwigtemplate.html.twig

    Displaying the {{ constant (‘NUM_ITEMS’ , post ) }} most recent results.
  2. Keep your controllers Thin

    Symfony follows the philosophy of “thin controllers and fat models”. This means that controllers should hold just the thin layer of glue-code needed to coordinate the different parts of the application. As a rule of thumb, you should follow the 5-10-20 rule, where controllers should only define 5 variablesor less, contain 10 actions or less and include 20 lines of code or less in each action. This isn’t an exact science, but it should help you realize when code should be refactored out of the controller and into a service.

    That’s an easy to remember Rule:
    5   Variables or less
    10 Actions (Calls to services / Forms validation, etc)
    20 Lines of code

    Storing hundred of lines for an Action is always a bad idea specially if you are not the only one working for the project.  And it mostly denotes some bad architectural start, since I can imagine that a controller Action has so many lines has parts that are common and can be reused in another actions. So why not to put all related actions in a service ?

    In this same Chapter, has a best practice that I consider really important, and is in my point of view how an ideal Symfony oriented project should be thought:
    You should aggressively decouple your business logic from the framework while, at the same time, aggressively coupling your controllers and routing to the framework in order to get the
    most out of Symfony

  3. Use eventListeners.
    As an example: Pre and Post Hooks
    If you need to execute some code before or after the execution of your controllers, you can use the EventDispatcher component to set up before/after filters

I find eventListeners one of the most cooles features. They are many use-cases, for example OneUp Uploader bundle uses it to handle File uploads, calling an event listener each time a file is uploaded through Ajax. Like that you can find many real use cases to do this kind of automatic things in the background.

If you like any other interesting part of this Symfony Best practices Book, feel free to join the conversation