Brisa Mística

Hi: I have just published my latest album called "Brisa Mística". It is available through several streaming services such as Spotify, Apple Music, CD Baby, Amazon Music, Deezer, etc. In memoriam of my mom: She already knew this music and she liked "El mensaje del viento"; she would have been happy of this release.… Continue reading Brisa Mística



Hace una semana se fue a un mejor lugar, dejó de sufrir esa enfermedad que la estaba consumiendo de a poquito los últimos cuatro meses, dejó de desesperarse por ya no poder ser lo que fue, como fue. Y sí, sé que está ahora en paz, pero ya no está aquí, ya no la escucharé… Continue reading Mamá

C++: “auto” on anonymous functions

C++14 introduced an improvement to the way we can declare anonymous functions (a.k.a. lambda expressions). For example, before C++14, if you wanted to pass an anonymous function to the sort algorithm, you had to do something like this: Since C++14, you can let the compiler to deduce the type of the variables passed as parameters… Continue reading C++: “auto” on anonymous functions

Music: “Stigmata” published

Hello, I have just published my second album: "Stigmata". It is already available through several streaming services such as Spotify, iTunes, CD Baby, Amazon, etc. Some info: Hardware used: MacBook Pro 13" mid-2012 Yamaha PSR-213e Casio CDP-220R Audio Technica ATH-M50x Software used: Renoise 3.1 Tempo Rubato's NLogPoly Synth Imperfect Samples' Steinway Walnut Concert Grand Piano… Continue reading Music: “Stigmata” published

C++11: std::tuple

A tuple is a C++11 construction and it is built heavily on variadic templates. A tuple is a variadic class template that stores an unlimited set of values of different types, defined when instantiating the tuple; for example: tuple<int, int> x; will store 2 integers. tuple<string, int, bool> y; will store one string, one integer… Continue reading C++11: std::tuple

Music: Introducing “poiesis” again and again


spotify:album:3JVSwbNPbs9A3E2CWFjrwH Though I composed this work on 1997; I am publishing it again with a lot of improvements and some changes: Modernized the sound a little bit. Removed a lot of noises and effects. Replaced several sampled instruments by AudioUnits. Started to use Renoise instead of OpenMPT and Impulse Tracker. Equalized, mixed and remastered again… Continue reading Music: Introducing “poiesis” again and again

C++: Smart pointers, part 5: weak_ptr

This is the last of several posts I wrote related to smart pointers: Smart pointers unique_ptr More on unique_ptr shared_ptr weak_ptr In modern C++ applications (C++11 and later), you can replace almost all your naked pointers to shared_ptr and unique_ptr in order to have automatic resource administration in a deterministic way so you will not… Continue reading C++: Smart pointers, part 5: weak_ptr

C++11: Perfect forwarding

Consider this function template invoke that invokes the function/functor/lambda expression passed as argument passing it the two extra arguments given: Nice, it works as expected and the result is: 30 Hello world The problem with my implementation is that it only works with arguments passed as constant references, so if I would like to invoke… Continue reading C++11: Perfect forwarding

C++: Smart pointers, part 4: shared_ptr

This is the fourth post of several posts I wrote related to smart pointers: Smart pointers unique_ptr More on unique_ptr shared_ptr weak_ptr As I mentioned in other posts, C++11 brings a new set of smart pointers into C++. The most useful smart pointer is shared_ptr: Its memory management policy consists in counting the number of… Continue reading C++: Smart pointers, part 4: shared_ptr

C++: Smart pointers, part 3: More on unique_ptr

This is the third post of several posts I wrote related to smart pointers: Smart pointers unique_ptr More on unique_ptr shared_ptr weak_ptr Ok, here I am going to write about two other features that unique_ptr has that I did not mention in my last post. unique_ptr default behavior consists on take ownership of a pointer… Continue reading C++: Smart pointers, part 3: More on unique_ptr

C++11: Smart Pointers, part 2: unique_ptr

This is the second post of several posts I wrote related to smart pointers: Smart pointers unique_ptr More on unique_ptr shared_ptr weak_ptr C++11 ships with a set of out-of-the-box smart pointers that help us to manage the memory easily. One of those smart pointers is the unique_ptr. Consider this piece of code: If you execute… Continue reading C++11: Smart Pointers, part 2: unique_ptr

C++11: std::future and std::async

C++11 introduces support for asynchronous calls in a very easy way. An asynchronous call is a method invocation that will be executed in a separate thread (or core or processor); so, the caller of the method does not wait for the result of the execution and continue doing what is next; in this way, the… Continue reading C++11: std::future and std::async

C++11: reference_wrapper

Look at this piece of code: This program supposedly adds 80 to 20 and prints the result; it compiles perfectly but when you execute it; you get.... 0! Why? Because the bind method receives its parameters as parameters-by-value and the "result" variable is copied before being passed to the bound function add. Why? Because bind… Continue reading C++11: reference_wrapper


Say you have this piece of code: If you compile the code you will get an error similar to this one: vec.cpp: In function 'int main()': vec.cpp:22:18: error: no matching function for call to 'show(int, int)' vec.cpp:22:18: note: candidate is: vec.cpp:7:57: note: template void show(typename T::iterator, typename T::iterator) And the error is quite obvious: your… Continue reading C++: SFINAE

C++11: std::function and std::bind

std::function and std::bind were born inside the Boost C++ Library, but they were incorporated into the new C++11 standard. std::function is a STL template class that provides a very convenient wrapper to a simple function, to a functor or to a lambda expression. For example, if you want to store several functions, functors or lambda… Continue reading C++11: std::function and std::bind