GeekWare - Daniel Pecos Martínez

Attending a PGP / GnuPG signing party

Tue, 23 Jan 2024 20:30:00 +0100

In today’s digital world, ensuring the authenticity and security of our communications is more important than ever. PGP (Pretty Good Privacy) and GnuPG (GNU Privacy Guard) are tools designed to provide secure encryption and decryption of data, playing a crucial role in protecting privacy and information. A key component of this security model is the “web of trust,” an informal network of users who verify and sign each other’s public keys. By hosting a PGP/GnuPG signing party, individuals can expand their web of trust, increasing the reliability of key verification and enhancing overall communication security. This guide offers practical steps, complete with GnuPG command examples, to help you host a successful signing party.

Before continuing, you should familiarize yourself with the concepts behind PGP/GnuPG, such as:

Public/Private keys
Encrypting content for someone else
Signing your data and verifying signatures
Key servers

This post does not cover those basics, but it’s really important that you feel comfortable with them in order to understand what you need to do.

Also, a while back I blogged about how to rotate and create subkeys for different use cases, you can read more here:

https://danielpecos.com/2019/03/30/how-to-rotate-your-openpgp-gnupg-keys/

Before the Party

Publish your public key

Check the instructions provided by the organizer of the key signing party. Sometimes you are requested to send your key to a specific email address a few days before the event, and sometimes you need to bring paper slips with your key details to hand over to other participants.

Likewise, sometimes the organizer will send you a file with the list of key details of the participants, but others you’ll be collecting paper slips from everyone with those details.

Double-check that you follow the correct steps detailed on the organization page.

But in any way, making your public key available on key servers is something nice, as it will ease the process of getting it signed. These are some of the most typical servers (usually these servers sync between each other, but you can manually send your key to as many as you want):

keys.openpgp.org
keyserver.ubuntu.org
pgp.mit.edu
keyserver.pgp.com

In order to publish your public key, you can use the following command:

gpg  --keyserver <server> --send-keys <your_key_id>

All the --send-keys and --recv-keys accept --keyserver to override your default key server (if any). I won’t be including this modifier in the following examples, but remember that’s an option if needed.

Prepare Key Information

Print out small slips of paper that contain your key’s fingerprint, your name, and email address. You should also include the key type (RSA, DSA, etc.), key size (2048-bit, 4096-bit, etc.), and the key’s full hexadecimal identifier. These slips can be handed out to others for key signing.

You can obtain those details via the following command:

gpg --fingerprint <your_key_id>

As an example, these are the details of my key:

$ gpg --fingerprint 0xE881015C8A55678B
pub   rsa4096 2019-03-27 [SC]
      31EF B482 E969 EB74 399D  BBC5 E881 015C 8A55 678B
uid           [ultimate] Daniel Pecos Martinez <me@danielpecos.com>
sub   rsa4096 2019-03-27 [E] [expires: 2024-03-25]
sub   rsa4096 2019-03-27 [S] [expires: 2024-03-25]

There are some tools that generate nice paperslip prints ready to cut:

https://openpgp.quelltextlich.at/slip.html
https://keysheet.net/
gpg-key2ps(arch pacakge): gpg-key2ps <your_key_id> | ps2pdf - key_slips.pdf

Identity Verification

Bring a valid photo ID to the party for verifying identities. You should not sign any key whose ownership identity and fingerprint have not been verified face to face and with a valid identity document.

People will rely on your signature when trusting third parties, so it’s really important to take this seriously. The web of trust is as strong as its weakest link, so let’s try not to introduce any.

During the Party

Usually, the way the signing party works is by forming two lines, connected on both ends (so it’s really a flattened circle), and you interact with the person you have in front of you. At that moment, you should:

Exchange key details, either by exchanging paper slips or by double-checking the provided key details with its owner
Verify the owner’s identity with an official document ID.

At the same time, you’re taking these steps, the person in front of you should be doing the same thing, so have your key details and ID ready to share as well.

Once you’re done, you just rotate to the person next to the current one, so the whole circle of people moves in the same direction. The signing party will end once you’ve performed a whole rotation, gathering and validating all the other attendees’ details.

After the Party

Once back at home, it’s time to sign the keys of the people whose details you’ve successfully verified.

You can do it one by one, or you can use some of the many tools available to automate the process. For the sake of understanding, I’ll explain the manual steps to follow to sign each key one by one.

Retrieve the key from a public key server or from the list of provided keys. To fetch it from a key server, you have to use the following command:

gpg --recv-keys <key_id>

Verify that the key ID, fingerprint, name, and email match the ones you’ve validated during the party:

gpg --fingerprint <key_id>

Once verified, sign the key:

gpg --sign-key --ask-cert-level <key_id>

Finally, you can either email the signed key to its owner or publish it back to a public server. The public server will take care of merging signatures.

NOTE: as David Sardari mentioned in the comments, sending an encrypted mail to the owner with his key and signed by you, is probably a better way of double checking the email address of the owner, as well as letting him/her decide where to publish it (if at all)

Likewise, your key will hopefully be signed by multiple people, so keep an eye on your mailbox to see if someone is sending your key with their signature, or pull it from a keyserver to check if there are new signatures attached:

gpg --recv-keys <your_key_id>

Or to refresh all your keys in your keyring:

gpg --refresh-keys

Conclusion

A PGP/GnuPG signing party is not just a gathering; it’s a fundamental step in building a robust web of trust. This trust network is vital for verifying the authenticity of public keys, thereby enhancing the security of digital communications. By participating in such events and following these steps, you contribute significantly to a more secure digital environment. Spread the knowledge, expand the web of trust, and continue to uphold the principles of digital security. Happy signing!

References

GnuPG / PGP key

Tue, 23 Jan 2024 14:15:00 +0100

My GnuPG key ID is:

0x8A55678B

0xE881015C8A55678B

31EFB482E969EB74399DBBC5E881015C8A55678B

and its fingerprint:

  31EF B482 E969 EB74 399D
  BBC5 E881 015C 8A55 678B

and you can download it here, copy it from down below, or fetch it from one of the public key servers:

Key 0x8A55678B

From Xorg to Wayland

Thu, 08 Jun 2023 10:07:00 +0200

Introduction

The landscape of Linux desktop environments has been undergoing a major transformation, with the advent of Wayland as a promising successor to the long-standing Xorg display server. This shift has brought about significant changes in popular desktop environments such as Plasma and GNOME. In this post, we explore the state of the art in terms of Wayland’s impact on these environments and how they compare to Xorg, as well as explaining my path towards moving from Xorg to Wayland, steps I took, mistakes I made, and learnings I’ve got.

But, first of all, why?

Basically, and I’m personal case, to follow the hype. As simple as that, no shame. There was no real need to leave my perfectly working Xorg environment just yet. But it was a great oportunity to get out of my confort zone and do some experimentation on my linux box, and maybe learn a couple of things.

So now that that’s out of the picture, let’s deep down on my path through this transition.

State of the art

Wayland: The Future Unfolding

Wayland represents a modern display protocol designed to overcome the limitations and shortcomings of Xorg, which had been the de facto standard for decades. Its main objective is to provide a secure, efficient, and flexible foundation for graphical environments. By taking advantage of the latest technologies and design principles, Wayland aims to offer smoother rendering, better performance, and improved security.

Plasma: Navigating the Wayland Path

The KDE Plasma desktop environment has been actively working towards embracing Wayland as the default display server. While Plasma has been historically associated with Xorg, recent iterations have made significant strides in Wayland compatibility. Users can now experience a native Wayland session with Plasma, benefiting from reduced input latency, improved multi-monitor support, and an overall more fluid experience. However, due to the inherent complexity of the transition, some legacy Xorg applications may still encounter compatibility issues.

GNOME: Pioneering the Wayland Experience

GNOME, one of the most popular Linux desktop environments, has been a front-runner in adopting Wayland as its primary display server. The GNOME Shell provides a seamless Wayland experience with full support for features such as fractional scaling, touchscreen gestures, and high-DPI displays. Thanks to GNOME’s early commitment to Wayland, many of its core applications have been optimized to work flawlessly under this new protocol. While Wayland support in GNOME is mature, occasional compatibility challenges with Xorg-dependent applications may still arise.

BTW, I use Arch

In order to install Wayland, I just installed the following packages (assuming you have a Xorg Plasma working installation):

wayland
egl-wayland: because I have an NVidia Optimus card in my laptop
plasma-wayland-session: so sddm gives you the option to log into Plasma on Wayland

One of the dependencies you’ll get as a result of installing the packages above is:

xorg-xwayland: a fallback solution to run X11 applications within a Wayland environment

Which will be vital, at the current moment, to be able to run applications that are not 100% supported yet, or that you’re experiencinig issues with.

Once these packages are installed, just restart the graphical environment (sddm) or reboot the computer and log in back into Plasma, without forgetting to switch to the Plasma (Wayland) session in SDDM. And if everything went all right, you are now using Wayland. One way to quickly confirm that is to open a terminal and run the following command:

$ echo $XDG_SESSION_TYPE

If you get ‘wayland’ back, you’ve got your confirmation. Congratulations!

There is one caveat though: at this moment not all the applications you may be using have support for Wayland yet, that’s where xwayland comes into the picture. One really nice debug tool I’ve found that lets you inspect which applications are running natively on Wayland is the following:

$ qdbus org.kde.KWin /KWin org.kde.KWin.showDebugConsole

which obviously is only available on Plasma.

Issue 1 - Longer application loading time

Usually my first action upon logging in is to open a terminal. alacritty is my terminal of choice, because:

it’s quite fast
cross-platform
configurable via YAML
it’s written in Rust

As usual, I pressed Ctrl + Alt + t to open a new terminal and… anda.. and… there it goes, it works! But it took a while… let’s try again… … … same :-(

Maybe it’s an issue with Alacritty, let’s check other apps like:

konsole: fast
dolphin: slower than usual
maybe okular: too long for such a small app
firefox: couldn’t tell if there was an actual difference (there wasn’t) - don’t forget to set up MOZ_ENABLE_WAYLAND=1 in your environment, otherwise it will be running under XWayland

And I’m talking a huge difference in loading times: from almost instantaneous loads under Xorg, to having to wait 2–3 seconds for the app just to appear. That can’t be right, people are for sure not going by with this huge performance difference, but… I can’t find any comment / post talking about this issue… :-(

Time to deep dive into the issue.

XWayland

Starting with alacritty, I searched for people reporting the same issue, and luckily, I found some. Their solution was to use something call XWayland.

XWayland is a tool that allows you to run non-Wayland apps on a Wayland environment. And you can use this tool on an app-by-app basis, which is really convenient. And that’s exactly what I did, as simple as setting up an empty value to WAYLAND_DISPLAY variable for alacritty and voilà, back to a blazingly-fast terminal, as it used to be.

Not really happy with the approach, but at this point I just wanted to focus on getting the rest of the apps ready, so I can use Wayland as I used to use Xorg. Something was not right, but at this point didn’t know what yet.

Digging on the dependencies that paru (or pacman) installed, I found one that was a little bit off: egl-wayland. Based on Arch’s wiki, this package provides EGLStreams API for NVidia GPUs. I have an internal NVidia GPU, but I wasn’t planning on using it, so I uninstalled this package (which also uninstalled nouveau, NVidia GPU’s opensource driver).

And after restarting the desktop environment, guess what? Everything was snappy and zero delays during start up. Even alacritty was fast running under Wayland without having to rely on XWayland.

Nice :-)

Issue #2: Steam requires Vulkan and EGL

I don’t game much, but I like to have Steam and a couple of games ready for whenever I want to disconnect a little bit, so, given that this kind of applications are quite graphic intensive, I decided to try it out under Wayland.

But it wasn’t there! It got uninstalled (and I didn’t notice it, shame on me) when I removed egl-wayland.

How could I resolve this conflict? Do I install back egl-wayland back, so I get back Steam and everything gets slower again, or should I ditch out gaming alltogether? That can’t be the current state of Wayland!?! I know the major distros are fully moving into Wayland, so this cannot be a general issue.

This needed more digging out across forums.

Wayland and NVidia: opensource or not?

I decided to install Steam again, and with it, egl-wayland, but this time something caught my attention during the installation: paru was asking me which NVidia drivers I wanted to install, the closed-source officials, or the opensource alternative nouveau.

I got this question during the first install attempt, and I decided to go for the opensource alternative wihout thinking it twice. But this time, after some reading about people complaining on some performance issues with nouveau, I decided to try the official drivers instead. So after the installation was done, I rebooted the computer, just to be sure that all the kernel modules are loaded properly, and logged back into Plasma.

And, oh wow, everything was running as smoothly as it was running before on Xorg. And no XWayland required at all!

Turns out my issue was on ’nouveau’ and not ’egl-wayland’.

Issue #3: Clipboard and Neovim

So that was it, I had a nice, fully Wayland native, Plasma desktop for me to use :-D

And so I did for a couple of days, and then I noticed a small nuance: I wasn’t able to copy from or to the system’s clipboard from neovim. Ok, this must be a minor one, for sure someone in the amazing Neovim community has solved thi issues.

Yep, easy one: just installed wl-clipboard and the issue was gone.

Conclusion

Not everything was smooth, but that’s how usually works on linux, and the beauty of it, because thanks to these issues, I learned a lot about Wayland and how the different desktop environments and window managers are transitioning to it.

I’m planning on gathering some metrics regarding the usage (or not) of the integrated Nvidia card, now that I’m using the official drivers. So keep an eye for my next post, coming soon!

(Psst! You can follow me on Mastodon or subscribe to my RSS feed not to miss it)

FOSDEM 2023

Sun, 05 Feb 2023 20:51:00 +0100

FOSDEM 2023 - A recap

This weekend I traveled to Brussels to attend FOSDEM 2023, although only for the first day (Saturday 4th, 2023). It hasn’t been my first one, but it has been the first massive event I have attended after the COVID-19 pandemic.

After the morning keynote, I had a quick look around the buildings where the event was hosted to visit the different stands of the many sponsors of the conference. Among the most interesting ones (for me personally, all the stands where really interesting in one way or another) where:

Mozilla
Gnome
PosgreSQL
VLC
Grafana
Ham Radio
Esprino (I’m still amazed about the Bangle.js 2 watch that I bought there)
And many, many others…
… oh, and the food trucks! :-P

It’s unbelievable the amount of people that usually come to FOSDEM. On one side it’s probably one of the nicest things about this conference: the amount of poeple you can find talking about really interesting stuff, from personal projects or showing some electronics that they hack together, to someone announcing a new sorting algorithm - Glidesort (btw, it hit Hacker News top 10! - repo here: https://github.com/orlp/glidesort)

On the other side, it’s always a big struggle trying to get into the room you are interested in, as chances are many other people are interested as well, and most probably there is not going to be enough room for everyone.

FOSDEM tip: if you are interested in a session and fear that it’s one of the popular ones, go to the session before (or 2 before) the one you’re interested and don’t get out!

The only thing I really missed (and chances are that it happened on Sunday, the day I could not attend) was the classic PGP / GPG signing party :-(

Nevertheless, once again FOSDEM has been an amazing event that I will most probably repeat next year!

Some pictures from the event:

Mastodon as comment system for your static blog

Sun, 25 Dec 2022 12:27:00 +0100

Comment systems are an essential part of modern websites, providing a platform for users to engage with the content and share their thoughts and opinions. While there are many options available for adding commenting functionality to a website, one alternative worth considering is integrating a Mastodon thread, also known as a “toot.”

Mastodon is an open-source, decentralized social media platform that allows users to share text, images, and other types of media in a manner similar to Twitter.

In this blog post, we will explore how to integrate a Mastodon thread into your static website as a way to replace traditional comment systems, using simple HTML and JavaScript. By the end of this tutorial, you will have a fully functional Mastodon thread on your website that allows users to participate in discussions and share their thoughts and ideas.

The Fediverse — Mastodon

Twitter is a centralized social media platform that allows users to share short messages, called “tweets,” along with images, videos, and other types of media. Twitter is owned by a private company and has a centralized structure, which means that all user data and content is stored on servers owned and operated by the company.

In contrast, Mastodon is a decentralized social media platform that is part of the Fediverse. The Fediverse is a network of interconnected, decentralized social media platforms that use the same open-source software and protocols, allowing users on different platforms to communicate with each other. Mastodon operates on a decentralized model, meaning that it is not owned or controlled by a single entity and user data and content is stored on servers run by individual users or organizations. This decentralized model allows for greater privacy and control over user data, as well as more diverse and independent communities.

In terms of functionality, Mastodon is similar to Twitter in that it allows users to share text, images, and other types of media in short messages called “toots.” However, Mastodon also has additional features, such as the ability to boost (similar to retweeting) and favorite toots, as well as the ability to customize your profile and the look and feel of your Mastodon instance (server).

Disqus

Using a third party commenting system like Disqus does involve some trade-offs, including the fact that you are giving up some control over your user data. When you use a third-party system like Disqus, the user data (such as comments, email addresses, and any personal information provided by users) is stored on servers owned and operated by Disqus. This means that you do not have direct control over this data, and you will have to rely on Disqus to properly secure and manage it.

There are a few potential disadvantages to not owning your user data when using a third party commenting system. First, you may be subject to the privacy policies and data handling practices of the third-party system, which may not align with your own policies or values. This can be especially concerning if you are collecting sensitive or personal information from your users, as you may not have control over how this information is used or shared.

Second, not owning your user data can also make it more difficult to migrate to a different commenting system or platform in the future. If you decide to switch to a different system, you may have to manually transfer all the user data from the third-party system to the new platform, which can be time-consuming and may not be possible in all cases.

Finally, using a third party commenting system can also potentially result in lost traffic to your website, as users may be directed to the third-party system’s website when they leave comments or log in to their accounts. This can be especially problematic if you are relying on advertising or other monetization methods that rely on website traffic.

Integrating a Mastodon Toot thread into your blog post

There are several potential advantages to integrating a blog post with the Fediverse, specifically Mastodon:

Increased visibility: By integrating your blog with Mastodon, you can potentially increase the visibility of your content by reaching a wider audience. Mastodon has a large and active user base, and by publishing your content on the platform, you can expose it to a new audience that may not have seen it otherwise.
Greater control over user data: Mastodon operates on a decentralized model, which means that user data is stored on servers run by individual users or organizations. This can give you greater control over your user data and how it is used, compared to using a third party commenting system like Disqus.
Improved user experience: Mastodon allows users to easily share and engage with your content, as they can simply “boost” (similar to retweeting) your toots to share them with their followers. This can create a more interactive and engaging experience for your readers.
Enhanced privacy: Mastodon has a strong focus on privacy and user control, which can be appealing to users who are concerned about the data handling practices of centralized platforms. By integrating with Mastodon, you can offer a more private and secure commenting system for your readers.
Stronger sense of community: Mastodon is known for fostering strong and independent communities, and by integrating your blog with the platform, you can potentially create a more cohesive and engaged community around your content.

The technical proposal is to have a specific toot thread per blog post, so that a Mastodon user would be able to post replies to your post in the thread itself, as any other toot you may publish in the Fediverse itself. The “only” thing left is to integrate that thread into your blog, as if those were comments from a classic system.

How? Thanks to Carl Schwan (@carlschwan@floss.social) who shared in a blogpost the Javscript code necessary to achieve this: https://carlschwan.eu/2020/12/29/adding-comments-to-your-static-blog-with-mastodon/

This is the code that I finally ended using, heavily based on Carl’s. The main differences are:

I’m importing the necessary libs from CloudFare’s CDN, not hosting those files directly
Toot is automatically loaded as soon as the user scrolls to that section of the page
and of course, the parameter names (which are based on Hugo and my modified hugo-tranquilpeak-theme)

I’ve refactored the code in this article into a standalone webcomponent, easy to use and integrate. Find the code in the following GitHub repository: mastodon-comments

<h2>Comments</h2>

<noscript>
  <div id="error">
    Please enable JavaScript to view the comments powered by the Fediverse.
  </div>
</noscript>

<p>You can use your Fediverse (i.e. Mastodon, among many others) account to reply to this <a class="link"
    href="https://{{ .Site.Params.comment.fediverse.host }}/@{{ .Site.Params.comment.fediverse.user }}/{{ .Params.fediverse }}">post</a>.
</p>
<p id="mastodon-comments-list"></p>

<script src="https://cdnjs.cloudflare.com/ajax/libs/dompurify/2.4.1/purify.min.js" integrity="sha512-uHOKtSfJWScGmyyFr2O2+efpDx2nhwHU2v7MVeptzZoiC7bdF6Ny/CmZhN2AwIK1oCFiVQQ5DA/L9FSzyPNu6Q==" crossorigin="anonymous" referrerpolicy="no-referrer"></script>
<script type="text/javascript">
  var host = '{{ .Site.Params.comment.fediverse.host }}';
  var user = '{{ .Site.Params.comment.fediverse.user }}';
  var id = '{{ .Params.fediverse }}'

  function escapeHtml(unsafe) {
    return unsafe
      .replace(/&/g, "&amp;")
      .replace(/</g, "&lt;")
      .replace(/>/g, "&gt;")
      .replace(/"/g, "&quot;")
      .replace(/'/g, "&#039;");
  }

  var commentsLoaded = false;

  function toot_active(toot, what) {
    var count = toot[what+'_count'];
    return count > 0 ? 'active' : '';
  }

  function toot_count(toot, what) {
    var count = toot[what+'_count'];
    return count > 0 ? count : '';
  }

  function user_account(account) {
    var result =`@${account.acct}`;
    if (account.acct.indexOf('@') === -1) {
      var domain = new URL(account.url)
      result += `@${domain.hostname}`
    }
    return result;
  }

  function render_toots(toots, in_reply_to, depth) {
    var tootsToRender = toots
      .filter(toot => toot.in_reply_to_id === in_reply_to)
      .sort((a, b) => a.created_at.localeCompare(b.created_at));
    tootsToRender.forEach(toot => render_toot(toots, toot, depth));
  }

  function render_toot(toots, toot, depth) {
    toot.account.display_name = escapeHtml(toot.account.display_name);
    toot.account.emojis.forEach(emoji => {
      toot.account.display_name = toot.account.display_name.replace(`:${emoji.shortcode}:`, `<img src="${escapeHtml(emoji.static_url)}" alt="Emoji ${emoji.shortcode}" height="20" width="20" />`);
    });
    mastodonComment =
      `<div class="mastodon-comment" style="margin-left: calc(var(--mastodon-comment-indent) * ${depth})">
        <div class="author">
          <div class="avatar">
            <img src="${escapeHtml(toot.account.avatar_static)}" height=60 width=60 alt="">
          </div>
          <div class="details">
            <a class="name" href="${toot.account.url}" rel="nofollow">${toot.account.display_name}</a>
            <a class="user" href="${toot.account.url}" rel="nofollow">${user_account(toot.account)}</a>
          </div>
          <a class="date" href="${toot.url}" rel="nofollow">${toot.created_at.substr(0, 10)} ${toot.created_at.substr(11, 8)}</a>
        </div>
        <div class="content">${toot.content}</div>
        <div class="attachments">
          ${toot.media_attachments.map(attachment => {
            if (attachment.type === 'image') {
              return `<a href="${attachment.url}" rel="nofollow"><img src="${attachment.preview_url}" alt="${attachment.description}" /></a>`;
            } else if (attachment.type === 'video') {
              return `<video controls><source src="${attachment.url}" type="${attachment.mime_type}"></video>`;
            } else if (attachment.type === 'gifv') {
              return `<video autoplay loop muted playsinline><source src="${attachment.url}" type="${attachment.mime_type}"></video>`;
            } else if (attachment.type === 'audio') {
              return `<audio controls><source src="${attachment.url}" type="${attachment.mime_type}"></audio>`;
            } else {
              return `<a href="${attachment.url}" rel="nofollow">${attachment.type}</a>`;
            }
          }).join('')}
        </div>
        <div class="status">
          <div class="replies ${toot_active(toot, 'replies')}">
            <a href="${toot.url}" rel="nofollow"><i class="fa fa-reply fa-fw"></i>${toot_count(toot, 'replies')}</a>
          </div>
          <div class="reblogs ${toot_active(toot, 'reblogs')}">
            <a href="${toot.url}" rel="nofollow"><i class="fa fa-retweet fa-fw"></i>${toot_count(toot, 'reblogs')}</a>
          </div>
          <div class="favourites ${toot_active(toot, 'favourites')}">
            <a href="${toot.url}" rel="nofollow"><i class="fa fa-star fa-fw"></i>${toot_count(toot, 'favourites')}</a>
          </div>
        </div>
      </div>`;
    document.getElementById('mastodon-comments-list').appendChild(DOMPurify.sanitize(mastodonComment, {'RETURN_DOM_FRAGMENT': true}));

    render_toots(toots, toot.id, depth + 1)
  }

  function loadComments() {
    if (commentsLoaded) return;

    document.getElementById("mastodon-comments-list").innerHTML = "Loading comments from the Fediverse...";

    fetch('https://' + host + '/api/v1/statuses/' + id + '/context')
      .then(function(response) {
        return response.json();
      })
      .then(function(data) {
        if(data['descendants'] && Array.isArray(data['descendants']) && data['descendants'].length > 0) {
            document.getElementById('mastodon-comments-list').innerHTML = "";
            render_toots(data['descendants'], id, 0)
        } else {
          document.getElementById('mastodon-comments-list').innerHTML = "<p>Not comments found</p>";
        }

        commentsLoaded = true;
      });
  }

  function respondToVisibility(element, callback) {
    var options = {
      root: null,
    };

    var observer = new IntersectionObserver((entries, observer) => {
      entries.forEach(entry => {
        if (entry.intersectionRatio > 0) {
          callback();
        }
      });
    }, options);

    observer.observe(element);
  }

  var comments = document.getElementById("mastodon-comments-list");
  respondToVisibility(comments, loadComments);
</script>

and the CSS supporting the generated HTML markup:

.mastodon-comment {
  background-color: var(--block-background-color);
  border-radius: var(--block-border-radius);
  border: 1px var(--block-border-color) solid;
  padding: 20px;
  margin-bottom: 1.5rem;
  display: flex;
  flex-direction: column;
  color: var(--font-color);
  font-size: var(--font-size);
}
.mastodon-comment p {
  margin-bottom: 0px;
}
.mastodon-comment .author {
  padding-top:0;
  display:flex;
}
.mastodon-comment .author a {
  text-decoration: none;
}
.mastodon-comment .author .avatar img {
  margin-right:1rem;
  min-width:60px;
  border-radius: 5px;
}
.mastodon-comment .author .details {
  display: flex;
  flex-direction: column;
}
.mastodon-comment .author .details .name {
  font-weight: bold;
}
.mastodon-comment .author .details .user {
  color: #5d686f;
  font-size: medium;
}
.mastodon-comment .author .date {
  margin-left: auto;
  font-size: small;
}
.mastodon-comment .content {
  margin: 15px 20px;
}
.mastodon-comment .attachments {
  margin: 0px 10px;
}
.mastodon-comment .attachments > * {
  margin: 0px 10px;
}
.mastodon-comment .content p:first-child {
  margin-top:0;
  margin-bottom:0;
}
.mastodon-comment .status > div {
  display: inline-block;
  margin-right: 15px;
}
.mastodon-comment .status a {
  color: #5d686f;
  text-decoration: none;
}
.mastodon-comment .status .replies.active a {
  color: #003eaa;
}
.mastodon-comment .status .reblogs.active a {
  color: #8c8dff;
}
.mastodon-comment .status .favourites.active a {
  color: #ca8f04;
}

You’ll need also to add some config to your config.toml:

as well as to the meta section of your post (the toot ID to use as a thread, last attribute of the following screenshot):

The code snippet above code, based on a toot ID that the post must define in its metadata, fetches via JSON the whole discussion thread. Once that’s done, it’s just a matter of sanitizing the HTML (to be sure nobody can inject JS into your blog but just replying to the toot) and rendering it into the HTML.

There is a small chicken and egg issue though: you need to know the ID of the toot to use as discussion thread to specify it as part of the post metadata, but probably (although not mandatory) you’d like to include the URL of the post itself, as part of the content of the toot (and ideally the link should work as soon as the toot is published).

Yes, you can edit toots, so you would be able to publish the toot, grab its ID, change the post and publish. The problem is that you’ll be losing the momentum that publishing a new toot gives you, as the toot would initially not contain the link to the blog post itself.

So my workflow, although not ideal, is going to be as follows:

Publish the post without Fediverse discussion enabled (no toot ID)
Publish the toot containing the URL to the post and grab its ID
Change the post to include the toot ID
Republish the website

It’s not ideal, as you are potentially loosing comments from early visitor to your post, but given that publishing a static website is quite fast, it should not be that many people.

And with that, you have a fresh new comment system based on the Fediverse for your blog!

Note: I’ve kept as a fallback for existing posts (with existing comments) Disqus, so if a post does not define a toot ID, then the comments system fall backs to Disqus. Ideally I’d love to move all those posts to Mastodon threads, but I don’t think that’s possible, as you’ll need to post toots on behalf of the users that created those comments (or you can use your own account and mimick the message as if they would have post it). Maybe something to explore in the future.

Thanks again to Carl Schwan (@carlschwan@floss.social) for its contribution to the community!

2023/01/01 Update — I’ve recently changed the markup (and some functionality) to include some extra features, as the botton links to boost / reply, as well as including the count. This is the latest code:

2023/01/02 Update — Quick hack to group / nest replies properly

2023/06/20 Update — Screenshots for blog config and post meta added

2023/06/23 Update — Media attachments rendered as part of the toot:

2023/06/24 Update — Sort comments by date

2023/07/19 Update - Added CSS snippet

2023/07/23 Update - Code refactored into a standalone webcomponent: mastodon-comments

Parchis: the reason why I am a developer

Sat, 06 Nov 2021 21:58:00 +0100

A while back, digging into an old DO NOT DELETE backup folder in one of my old hard drives, I stumped upon a folder called parchis, and for a moment I held my breath until I found some *.bas files there!

So what?

Well, I just found the lost source code of my very first project, the one I coded while learning about variables, procedures and loops, the one that made me realize that this is the kind of stuff I wanted to do as my professional career and hobby.

The one that made me love coding.

But before explaining further, let me explain what the Parchís game is about, and for that I’m going to borrow the definition from the Wikipedia:

Parchís is a Spanish board game of the Cross and Circle family. It is an adaptation of the Indian game Pachisi. Parchís was a very popular game in Spain at one point as well as in Europe and north Morocco - specifically Tangiers and Tetouan, and it is still popular specially among adults and seniors. Since it uses dice, Parchís is not usually regarded as an abstract strategy game like checkers or chess. It does not depend entirely on luck either, since the four pawns under a player’s command demand some sort of strategy.

So here I am, 17 years old me, learning how to code from a book I borrowed from the library about QuickBasic. Yep, back then Internet was not a thing yet (at least not much yet in Spain), so that was how we used to browse and learn new topics, by going to a library. And, oh did I enjoy it.

I still don’t know what exactly hooked me up, but there I was writing this weird mixed of English & Spanish that the computer was able to understand, using this archaic environment in MS-DOS. Maybe it was being able to finally understand how games were made, or the beauty of taking a problem and plan and design a solution, and not only that, taking care of the solution being elegant and simple. Pure beauty.

But anyway, after a few weeks (if I remember correctly), I managed to put something together that resembled the game I was aiming for and that kind of worked. To be honest, trying to read the code today is quite painful, and hard to keep all the logic and structure in your head, which makes me even prouder of being able of making it work being so poorly written.

This is how the program looks like:

And no, the screenshot is not from back then, but from a couple of days ago, when I found the source code. I wanted to check if it was possible to still run that code, so I started digging about modern quick basic interpreters, and found some, but at the end the best solution was to use dosbox, a MS-DOS emulator and installing QuickBasic 4.5 to open the software.

And lo and behold, it worked!

(BTW, I use Arch, and this is running on Arch Linux)

I’ve put all the code together in a Github repository, where I’ve fixed some MS-DOS encoding issues and cleaned a little bit the code, but I’ve kept all the original comments, bugs and code smells that I wrote back then. There are some instructions on how to get it running, just in case you are interested on running old QuickBasic programs.

I don’t want to change a single bit of it, but I want to be able to look at it from time to time and remember how all of this started.

If you’d like to have a look, feel free, although I doubt you’ll find any value on the code itself, it’s ugly, poorly written, anb barely works, but to me :-)

https://github.com/dpecos/parchis

And if you’d like to actually see how I got it up and running, here you have a small screencast of the process and gameplay:

Last but not least, I have to say that it was my friend Alfredo who actually introduced me to software development, showing me a couple of small programs he was developing to learn QuickBasic, and triggering my curiosity about it, leading towards this project.

So basically all of this is his fault. Thx for that Alfredo ;-)

Cryptocurrencies and Climate Change

Wed, 03 Mar 2021 10:50:00 +0100

Bitcoin (and many more) cryptocurrency prices have been sky rocketing for the lasts weeks/months, and thus their usage and mining. But have we stop thinking how this impacts the Climate Change?

Before jumping into graphs, a quick recap on how cryptocurrencies work: when you buy or sell Bitcoins (for example), your transaction is being recorded into a distributed ledger. This distributed ledger is cryptographically secured against tampering, meaning that once anything is written into it, there is no way of changing nor removing it. But that ledger needs to reside and be supported by a platform. This platform is what the miners provide, and the computation power they contribute with is what enables the distributed ledger.

I’ve covered more in detail here and here how blockchain works and how you could have a basic implementation with a few lines of code.

The issue here is that in order to seal the ledger’s records, a really hard computation is performed in parallel across all the miners in the world, as a race to be the first to figure out the challenge and earn some coins (the transaction fees) in exchange.

This process is extremely inefficient and power demanding, and this is why it should concern us. A lot.

Based on different articles, power consumption for bitcoin (alone) is higher than some countries (and not exactly third world countries):

This is worrisome, to say the least: we’re generating an incredible amount of CO2 that is not yielding anything useful in return. I’m not saying cryptocurrencies are not useful, but that cryptocurrencies (based on proof-of-work) are not worth it if to make them work we increase our chances of having a climate disaster in the close future.

Please, I know it’s tempting to buy Bitcoins, I’ve did it in the past and vouched for these kind of coins to be a way of monetizing the web, but this is out of control and, IMHO, not worth it at all.

How I write AWS SES email templates using MJML

Wed, 27 Jan 2021 09:05:00 +0100

If you are a AWS SES user (AWS’ email system) you probably know that working with its JSON based templates is not a user-friendly task:

Text and HTML content are defined as properties of a JSON object
It’s a JSON file, meaning that you have to escape some characters, like " in the HTML
It’s quite hard to find the content to change in the HTML being stored in a single line

But still, is a quite convenient system, as hosting your own email server is quite an effort, and you want it to be reliable.

That’s why I decided to use it, despite the not so friendly interface. Together with a Lambda function triggered by SNS messages, I have managed to build a quite robust mail gateway solution for Papyro (let me know if you are interested in knowing how theses pieces fit together and I’ll write a future post about it).

But the pain of creating some nice looking emails using this system is way too much from the moment that you have to manage more than 3 or 4 email templates.

That’s when I started looking into MJML. MJML is a responsive email library that allows you to create rich emails using a syntax similar to HTML. It also offers a CLI to convert the MJML files into (minimized, and this is important) HTML.

So in order to use MJML for SES templates, two issues needed to be adressed:

Generate plain text from MJML - not supported directly by MJML
All generated output must be valid when expressed in a single line - because still, the output must be part of a JSON property in the SES template

For 1, and given an already minimized HTML, it’s just a matter of removing all the \n and making sure that the generated CSS does not contain any problematic comment (which by default, is the case, phew).

For 2, I decided to use html-to-text (https://www.npmjs.com/package/html-to-text) node package (specifically its CLI) and some bash magic to properly format the contents in the format that AWS expects (using \r\n for line breaks).

So this is what my solution looks like:

├── bin
│   └── upload-ses-template.sh
├── build
│   └── welcome.json
└── templates
    ├── welcome.json
    └── welcome.mjml

This bash script is driving all the process (upload-ses-template.sh):

#!/usr/bin/env bash

TEMPLATE=$1

RAW_HTML=$(mjml ./templates/$TEMPLATE.mjml --config.minify true)

HTML=$(echo $RAW_HTML | sed -e 's/"/\\\\"/g')

TEXT=$(echo $RAW_HTML | html-to-text --ignore-image --noLinkBrackets | sed -e 's/"/\\\\"/g')
TEXT=$(while IFS= read -r line; do echo "$line\\\\r\\\\n"; done <<< "$TEXT" | tr -d '\n')

mkdir -p ./build
cat ./templates/$TEMPLATE.json | sed -e "s~%html%~$HTML~" -e 's/%html%/\&/g' -e "s~%text%~$TEXT~" -e 's/%text%/\&/g' > ./build/$TEMPLATE.json

cat ./build/$TEMPLATE.json

set -x

aws ses delete-template --template-name papyro-$TEMPLATE
aws ses create-template --cli-input-json file://build/$TEMPLATE.jso

(BTW, if you know a better way of joining a multiline text using \r\n, please let me know, I did struggle quite a bit and the solution is not that nice as you may have noticed)

So given a wireframe (note the %text% and %html% placeholders) of SES template (templates/welcome.json):

{
  "Template": {
    "TemplateName": "papyro-welcome",
    "SubjectPart": "Welcome to Papyro!",
    "TextPart": "%text%",
    "HtmlPart": "%html%"
  }
}

and its MJML template (templates/welcome.mjml):

<mjml>
  <mj-head>
    <mj-title>Papyro</mj-title>
  </mj-head>

  <mj-body>
    <mj-section>
      <mj-column>
        <mj-image width="100px" src="https://app.papyro.dplabs.tech/assets/app-logo/logo.png"></mj-image>
        <mj-divider border-color="#fcba03"></mj-divider>

        <mj-text font-size="20px" color="#fcba03" font-family="helvetica">Hello {{name}}!</mj-text>

        <mj-text font-size="16px" font-family="helvetica">Welcome to Papyro!</mj-text>

        <mj-text font-size="16px" font-family="helvetica">Before starting, we need to validate your email. Click in this link to proceed:</mj-text>

        <mj-button font-size="20px" font-family="helvetica" background-color="#fcba03" href="{{link}}"> Validate email </mj-button>

        <mj-text font-size="20px" color="#fcba03" font-family="helvetica">Papyro Team.</mj-text>
      </mj-column>
    </mj-section>
  </mj-body>
</mjml>

the script generates a valid AWS SES template file (build/welcome.json) and uploads to SES it using aws cli:

$ ./bin/upload-ses-template.sh welcome
{
  "Template": {
    "TemplateName": "papyro-welcome",
    "SubjectPart": "Welcome to Papyro!",
    "TextPart": "Hello {{name}}!\r\nWelcome to Papyro!\r\nBefore starting, we need to validate your email. Click in this link to proceed:\r\n\r\nValidate email {{link}}\r\n\r\nPapyro Team.\r\n",
    "HtmlPart": "<!-- FILE: ./templates/welcome.mjml --> <!doctype html><html xmlns=\"http://www.w3.org/1999/xhtml\" xmlns:v=\"urn:schemas-microsoft-com:vml\" xmlns:o=\"urn:schemas-microsoft-com:office:office\"><head><title>Papyro</title><!--[if !mso]><!--><meta http-equiv=\"X-UA-Compatible\" content=\"IE=edge\"><!--<![endif]--><meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\"><meta name=\"viewport\" content=\"width=device-width,initial-scale=1\"><style type=\"text/css\">#outlook a { padding: 0; } body { margin: 0; padding: 0; -webkit-text-size-adjust: 100%; -ms-text-size-adjust: 100%; } table, td { border-collapse: collapse; mso-table-lspace: 0pt; mso-table-rspace: 0pt; } img { border: 0; height: auto; line-height: 100%; outline: none; text-decoration: none; -ms-interpolation-mode: bicubic; } p { display: block; margin: 13px 0; }</style><!--[if mso]> <xml> <o:OfficeDocumentSettings> <o:AllowPNG/> <o:PixelsPerInch>96</o:PixelsPerInch> </o:OfficeDocumentSettings> </xml> <![endif]--><!--[if lte mso 11]> <style type=\"text/css\"> .mj-outlook-group-fix { width:100% !important; } </style> <![endif]--><style type=\"text/css\">@media only screen and (min-width:480px) { .mj-column-per-100 { width: 100% !important; max-width: 100%; } }</style><style type=\"text/css\">@media only screen and (max-width:481px) { table.mj-full-width-mobile { width: 100% !important; } td.mj-full-width-mobile { width: auto !important; } }</style></head><body style=\"word-spacing:normal;\"><div><!--[if mso | IE]><table align=\"center\" border=\"0\" cellpadding=\"0\" cellspacing=\"0\" class=\"\" style=\"width:600px;\" width=\"600\" ><tr><td style=\"line-height:0px;font-size:0px;mso-line-height-rule:exactly;\"><![endif]--><div style=\"margin:0px auto;max-width:600px;\"><table align=\"center\" border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style=\"width:100%;\"><tbody><tr><td style=\"direction:ltr;font-size:0px;padding:20px 0;text-align:center;\"><!--[if mso | IE]><table role=\"presentation\" border=\"0\" cellpadding=\"0\" cellspacing=\"0\"><tr><td class=\"\" style=\"vertical-align:top;width:600px;\" ><![endif]--><div class=\"mj-column-per-100 mj-outlook-group-fix\" style=\"font-size:0px;text-align:left;direction:ltr;display:inline-block;vertical-align:top;width:100%;\"><table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style=\"vertical-align:top;\" width=\"100%\"><tbody><tr><td align=\"center\" style=\"font-size:0px;padding:10px 25px;word-break:break-word;\"><table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style=\"border-collapse:collapse;border-spacing:0px;\"><tbody><tr><td style=\"width:100px;\"><img height=\"auto\" src=\"https://app.papyro.dplabs.tech/assets/app-logo/logo.png\" style=\"border:0;display:block;outline:none;text-decoration:none;height:auto;width:100%;font-size:13px;\" width=\"100\"></td></tr></tbody></table></td></tr><tr><td align=\"center\" style=\"font-size:0px;padding:10px 25px;word-break:break-word;\"><p style=\"border-top:solid 4px #fcba03;font-size:1px;margin:0px auto;width:100%;\"></p><!--[if mso | IE]><table align=\"center\" border=\"0\" cellpadding=\"0\" cellspacing=\"0\" style=\"border-top:solid 4px #fcba03;font-size:1px;margin:0px auto;width:550px;\" role=\"presentation\" width=\"550px\" ><tr><td style=\"height:0;line-height:0;\"> &nbsp; </td></tr></table><![endif]--></td></tr><tr><td align=\"left\" style=\"font-size:0px;padding:10px 25px;word-break:break-word;\"><div style=\"font-family:helvetica;font-size:20px;line-height:1;text-align:left;color:#fcba03;\">Hello {{name}}!</div></td></tr><tr><td align=\"left\" style=\"font-size:0px;padding:10px 25px;word-break:break-word;\"><div style=\"font-family:helvetica;font-size:16px;line-height:1;text-align:left;color:#000000;\">Welcome to Papyro!</div></td></tr><tr><td align=\"left\" style=\"font-size:0px;padding:10px 25px;word-break:break-word;\"><div style=\"font-family:helvetica;font-size:16px;line-height:1;text-align:left;color:#000000;\">Before starting, we need to validate your email. Click in this link to proceed:</div></td></tr><tr><td align=\"center\" vertical-align=\"middle\" style=\"font-size:0px;padding:10px 25px;word-break:break-word;\"><table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style=\"border-collapse:separate;line-height:100%;\"><tr><td align=\"center\" bgcolor=\"#fcba03\" role=\"presentation\" style=\"border:none;border-radius:3px;cursor:auto;mso-padding-alt:10px 25px;background:#fcba03;\" valign=\"middle\"><a href=\"{{link}}\" style=\"display:inline-block;background:#fcba03;color:#ffffff;font-family:helvetica;font-size:20px;font-weight:normal;line-height:120%;margin:0;text-decoration:none;text-transform:none;padding:10px 25px;mso-padding-alt:0px;border-radius:3px;\" target=\"_blank\">Validate email</a></td></tr></table></td></tr><tr><td align=\"left\" style=\"font-size:0px;padding:10px 25px;word-break:break-word;\"><div style=\"font-family:helvetica;font-size:20px;line-height:1;text-align:left;color:#fcba03;\">Papyro Team.</div></td></tr></tbody></table></div><!--[if mso | IE]></td></tr></table><![endif]--></td></tr></tbody></table></div><!--[if mso | IE]></td></tr></table><![endif]--></div></body></html>"
  }
}
+ aws ses delete-template --template-name papyro-welcome
+ aws ses create-template --cli-input-json file://build/welcome.json

resulting in an email looking like this:

Hope this could be useful to someone else. I used to hate having to create emails, but now I can easily do it and I get really nice results with little effort.

What is a Monorepo

Wed, 26 Feb 2020 20:35:00 +0100

Definition: A monorepo is a standard Version Control System, or VCS (such as Git, Subversion or CVS) repository, which instead of containing just one application or unit of software (applications, libraries, micro services, modules…), contains all the components that a project (or company) needs to operate.

At first glance, it sounds counterintuitive to host more than one unit of software in a single repository, but there are few advantages on having all components stored in the same place:

All dependencies are easily within reach, just in a different path
Multiple-project changes in a single changeset
No more versioning issues between internal modules, all of them are always in sync
Easier to share knowledge between teams, their code is just there for you to change

Why then, would you ask, have we typically used single repositories until recently? Well, there are a few reasons also:

Code isolation
Smaller repository size
Access control to the code
Higher chance of merge conflicts
Easier to deploy

So there are some tradeoffs to using one approach or the other, some of them are greater than others, but also probably harder to grasp.

In this series of posts we will deep down into how to properly structure a monorepo, tools that can help us manage it and challenges that you and your team will face in the transition to a monorepo.

Will the effort be worth it? Subscribe to our feed to figure it out

Image credit: Erzhan Torokulov (https://medium.com/@erzhtor/javascript-monorepo-with-lerna-5729d6242302)

JCrete 2019

Sat, 20 Jul 2019 22:57:27 +0200

Amazing. That’s the one word summary for this unconference.

It wasn’t my first time in an unconference, although the previous ones were slightly smaller and my experience then wasn’t that satisfactory as the one I’ve had in JCrete. And I have just discovered the key ingredient for a successful unconference: the people.

Because is not only about the technical content of the sessions (which was quite high, don’t get me wrong), but about those interactions during and after the sessions, happening without any planification, as natural as a conversation can be. Probably the most interesting ones are, in fact, those unexpected gatherings happening at random places, like at the beach, or during breakfast, or while trekking to Balos beach, or while snokerkeling in a beautiful location of the island.

And that’s because of the people willing to share, discuss and talk about almost any subject, while being open and friendly to opposite ideas.

I’m really glad that I got the chance to participate in JCrete 2019 (even proposing, as you should do in any unconference, an small session about F.I.R.E, and I hope next year I’ll get the chance to hang out with all the awesome people I’ve met in the beautiful island of Crete.

How to rotate your OpenPGP / GnuPG keys

Sat, 30 Mar 2019 18:05:18 +0100

It’s been a while (well, years) since I rotated my GPG keys, and to be honest, now that I know better how to handle a GPG key pair in order to avoid master key rotation, I think it’s the time to get a new pair.

This tutorial will show you the steps I followed with explanations on what we are achieving in every step.

Environment

This is the GnuPG version used in this tutorial (if you are using a different version, probably not every command would work the same, but I wouldn’t expect for the concept to change that much):

$ gpg --version
gpg (GnuPG) 2.2.14
libgcrypt 1.8.4
Copyright (C) 2019 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <https://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

Home: /Users/dpecos/.gnupg
Supported algorithms:
Pubkey: RSA, ELG, DSA, ECDH, ECDSA, EDDSA
Cipher: IDEA, 3DES, CAST5, BLOWFISH, AES, AES192, AES256, TWOFISH,
        CAMELLIA128, CAMELLIA192, CAMELLIA256
Hash: SHA1, RIPEMD160, SHA256, SHA384, SHA512, SHA224
Compression: Uncompressed, ZIP, ZLIB, BZIP2

If you’re using MacOSX, you will need this application to handle password prompts:

brew install pinentry-mac

Create a new key pair

Let’s start generating the new key pair, without expiration date (we will be able to set one if needed in the future):

$ gpg --full-generate-key
gpg (GnuPG) 2.2.14; Copyright (C) 2019 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

Please select what kind of key you want:
  (1) RSA and RSA (default)
  (2) DSA and Elgamal
  (3) DSA (sign only)
  (4) RSA (sign only)
Your selection? 1
RSA keys may be between 1024 and 4096 bits long.
What keysize do you want? (2048) 4096
Requested keysize is 4096 bits
Please specify how long the key should be valid.
        0 = key does not expire
      <n>  = key expires in n days
      <n>w = key expires in n weeks
      <n>m = key expires in n months
      <n>y = key expires in n years
Key is valid for? (0) 0
Key does not expire at all
Is this correct? (y/N) y

GnuPG needs to construct a user ID to identify your key.

Real name: Daniel Pecos Martinez
Email address: me@danielpecos.com
Comment:
You selected this USER-ID:
    "Daniel Pecos Martinez <me@danielpecos.com>"

Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? o
We need to generate a lot of random bytes. It is a good idea to perform
some other action (type on the keyboard, move the mouse, utilize the
disks) during the prime generation; this gives the random number
generator a better chance to gain enough entropy.
We need to generate a lot of random bytes. It is a good idea to perform
some other action (type on the keyboard, move the mouse, utilize the
disks) during the prime generation; this gives the random number
generator a better chance to gain enough entropy.
gpg: key E881015C8A55678B marked as ultimately trusted
gpg: revocation certificate stored as '/Users/dpecos/.gnupg/openpgp-revocs.d/31EFB482E969EB74399DBBC5E881015C8A55678B.rev'
public and secret key created and signed.

pub   rsa4096 2019-03-27 [SC]
      31EFB482E969EB74399DBBC5E881015C8A55678B
uid                      Daniel Pecos Martinez <me@danielpecos.com>
sub   rsa4096 2019-03-27 [E]

We got the key ID 31EFB482E969EB74399DBBC5E881015C8A55678B, which we’ll be using to reference the key whenever needed (like editing the key, adding signatures, …).

Note that a revocation certificate has already been created, so we don’t need to create a new one if we don’t want:

gpg: revocation certificate stored as '/Users/dpecos/.gnupg/openpgp-revocs.d/31EFB482E969EB74399DBBC5E881015C8A55678B.rev'

Add UIDs

Now let’s add any extra ID that we would want to use to the key pair. This step is optional and should be repeated as many times as needed. In my case I’d like to add an extra UID:

$ gpg --edit-key 31EFB482E969EB74399DBBC5E881015C8A55678B
gpg (GnuPG) 2.2.14; Copyright (C) 2019 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

Secret key is available.

sec  rsa4096/E881015C8A55678B
    created: 2019-03-27  expires: never       usage: SC
    trust: ultimate      validity: ultimate
ssb  rsa4096/89BF354A17A61CC5
    created: 2019-03-27  expires: never       usage: E
[ultimate] (1). Daniel Pecos Martinez <me@danielpecos.com>

gpg> adduid
Real name: Daniel Pecos Martinez
Email address: dani@dplabs.io
Comment:
You selected this USER-ID:
    "Daniel Pecos Martinez <dani@dplabs.io>"

Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? o

sec  rsa4096/E881015C8A55678B
    created: 2019-03-27  expires: never       usage: SC
    trust: ultimate      validity: ultimate
ssb  rsa4096/89BF354A17A61CC5
    created: 2019-03-27  expires: never       usage: E
[ultimate] (1)  Daniel Pecos Martinez <me@danielpecos.com>
[ unknown] (2). Daniel Pecos Martinez <dani@dplabs.io>

gpg> uid 2

sec  rsa4096/E881015C8A55678B
    created: 2019-03-27  expires: never       usage: SC
    trust: ultimate      validity: ultimate
ssb  rsa4096/89BF354A17A61CC5
    created: 2019-03-27  expires: never       usage: E
[ultimate] (1)  Daniel Pecos Martinez <me@danielpecos.com>
[ unknown] (2)* Daniel Pecos Martinez <dani@dplabs.io>

gpg> trust
sec  rsa4096/E881015C8A55678B
    created: 2019-03-27  expires: never       usage: SC
    trust: ultimate      validity: ultimate
ssb  rsa4096/89BF354A17A61CC5
    created: 2019-03-27  expires: never       usage: E
[ultimate] (1)  Daniel Pecos Martinez <me@danielpecos.com>
[ unknown] (2)* Daniel Pecos Martinez <dani@dplabs.io>

Please decide how far you trust this user to correctly verify other users' keys
(by looking at passports, checking fingerprints from different sources, etc.)

  1 = I don't know or won't say
  2 = I do NOT trust
  3 = I trust marginally
  4 = I trust fully
  5 = I trust ultimately
  m = back to the main menu

Your decision? 5
Do you really want to set this key to ultimate trust? (y/N) y

sec  rsa4096/E881015C8A55678B
    created: 2019-03-27  expires: never       usage: SC
    trust: ultimate      validity: ultimate
ssb  rsa4096/89BF354A17A61CC5
    created: 2019-03-27  expires: never       usage: E
[ultimate] (1)  Daniel Pecos Martinez <me@danielpecos.com>
[ unknown] (2)* Daniel Pecos Martinez <dani@dplabs.io>

gpg> save

Now that we have multiple UIDs within the same key, it’s important to check that the primary UID is properly set. If not, we have to change it:

$ gpg --edit-key 31EFB482E969EB74399DBBC5E881015C8A55678B
gpg (GnuPG) 2.2.14; Copyright (C) 2019 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

Secret key is available.

sec  rsa4096/E881015C8A55678B
    created: 2019-03-27  expires: never       usage: SC
    trust: ultimate      validity: ultimate
ssb  rsa4096/89BF354A17A61CC5
    created: 2019-03-27  expires: never       usage: E
[ultimate] (1). Daniel Pecos Martinez <dani@dplabs.io>
[ultimate] (2)  Daniel Pecos Martinez <me@danielpecos.com>

gpg> uid 2

sec  rsa4096/E881015C8A55678B
    created: 2019-03-27  expires: never       usage: SC
    trust: ultimate      validity: ultimate
ssb  rsa4096/89BF354A17A61CC5
    created: 2019-03-27  expires: never       usage: E
[ultimate] (1). Daniel Pecos Martinez <dani@dplabs.io>
[ultimate] (2)* Daniel Pecos Martinez <me@danielpecos.com>

gpg> primary

sec  rsa4096/E881015C8A55678B
    created: 2019-03-27  expires: never       usage: SC
    trust: ultimate      validity: ultimate
ssb  rsa4096/89BF354A17A61CC5
    created: 2019-03-27  expires: never       usage: E
[ultimate] (1)  Daniel Pecos Martinez <dani@dplabs.io>
[ultimate] (2)* Daniel Pecos Martinez <me@danielpecos.com>

gpg> save

Create subkeys

At this moment, we have a key pair generated and containing the UIDs we want to use, and we could be good to go, but, what would happen if we lost the laptop where this key pair is stored? We would have to revoke them and generate a new key pair, loosing all its signatures and the trust gathered with time.

In order to avoid this situation is a common (and good) practice to generate what is known as laptop keys. These keys are disposable keys that are linked to your master key and that you would copy to the device where you would use them as usual, keeping the master key safe offline.

If by any eventuality you’d loose access to those laptop keys you could easily revoke them with the master key and generate a new set to replace them, but the master key pair (and thus your PGP/GPG ID) would remain the same.

Sounds good? Let’s generate a new subkey for signing. If you’ve paid attention to the process you’d have notice that a subkey for encrypting was already generated for your master key (ssb rsa4096/89BF354A17A61CC5 with usage: E), so no need to generate an extra key for that, as we already got one:

$ gpg --edit-key 31EFB482E969EB74399DBBC5E881015C8A55678B
gpg (GnuPG) 2.2.14; Copyright (C) 2019 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

Secret key is available.

sec  rsa4096/E881015C8A55678B
    created: 2019-03-27  expires: never       usage: SC
    trust: ultimate      validity: ultimate
ssb  rsa4096/89BF354A17A61CC5
    created: 2019-03-27  expires: never       usage: E
[ultimate] (1). Daniel Pecos Martinez <me@danielpecos.com>
[ultimate] (2)  Daniel Pecos Martinez <dani@dplabs.io>

gpg> addkey
Please select what kind of key you want:
  (3) DSA (sign only)
  (4) RSA (sign only)
  (5) Elgamal (encrypt only)
  (6) RSA (encrypt only)
Your selection? 4
RSA keys may be between 1024 and 4096 bits long.
What keysize do you want? (2048) 4096
Requested keysize is 4096 bits
Please specify how long the key should be valid.
        0 = key does not expire
      <n>  = key expires in n days
      <n>w = key expires in n weeks
      <n>m = key expires in n months
      <n>y = key expires in n years
Key is valid for? (0) 5y
Key expires at Mon Mar 25 15:42:11 2024 CET
Is this correct? (y/N) y
Really create? (y/N) y
We need to generate a lot of random bytes. It is a good idea to perform
some other action (type on the keyboard, move the mouse, utilize the
disks) during the prime generation; this gives the random number
generator a better chance to gain enough entropy.

sec  rsa4096/E881015C8A55678B
    created: 2019-03-27  expires: never       usage: SC
    trust: ultimate      validity: ultimate
ssb  rsa4096/89BF354A17A61CC5
    created: 2019-03-27  expires: never       usage: E
ssb  rsa4096/665E29633F97EF11
    created: 2019-03-27  expires: 2024-03-25  usage: S
[ultimate] (1). Daniel Pecos Martinez <me@danielpecos.com>
[ultimate] (2)  Daniel Pecos Martinez <dani@dplabs.io>

gpg> save

Note that I’ve set up an expire date for this subkey, as I want to rotate them from time to time. We would probably also want to set an expire date for the previously created encryption subkey:

$ gpg --edit-key 31EFB482E969EB74399DBBC5E881015C8A55678B
gpg (GnuPG) 2.2.14; Copyright (C) 2019 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

Secret key is available.

sec  rsa4096/E881015C8A55678B
    created: 2019-03-27  expires: never       usage: SC
    trust: ultimate      validity: ultimate
ssb  rsa4096/89BF354A17A61CC5
    created: 2019-03-27  expires: never       usage: E
ssb  rsa4096/665E29633F97EF11
    created: 2019-03-27  expires: 2024-03-25  usage: S
[ultimate] (1). Daniel Pecos Martinez <me@danielpecos.com>
[ultimate] (2)  Daniel Pecos Martinez <dani@dplabs.io>

gpg> key 1

sec  rsa4096/E881015C8A55678B
    created: 2019-03-27  expires: never       usage: SC
    trust: ultimate      validity: ultimate
ssb* rsa4096/89BF354A17A61CC5
    created: 2019-03-27  expires: never       usage: E
ssb  rsa4096/665E29633F97EF11
    created: 2019-03-27  expires: 2024-03-25  usage: S
[ultimate] (1). Daniel Pecos Martinez <me@danielpecos.com>
[ultimate] (2)  Daniel Pecos Martinez <dani@dplabs.io>

gpg> expire
Changing expiration time for a subkey.
Please specify how long the key should be valid.
        0 = key does not expire
      <n>  = key expires in n days
      <n>w = key expires in n weeks
      <n>m = key expires in n months
      <n>y = key expires in n years
Key is valid for? (0) 5y
Key expires at Mon Mar 25 15:44:22 2024 CET
Is this correct? (y/N) y

sec  rsa4096/E881015C8A55678B
    created: 2019-03-27  expires: never       usage: SC
    trust: ultimate      validity: ultimate
ssb* rsa4096/89BF354A17A61CC5
    created: 2019-03-27  expires: 2024-03-25  usage: E
ssb  rsa4096/665E29633F97EF11
    created: 2019-03-27  expires: 2024-03-25  usage: S
[ultimate] (1). Daniel Pecos Martinez <me@danielpecos.com>
[ultimate] (2)  Daniel Pecos Martinez <dani@dplabs.io>

gpg> save

Rotate your previous key pair

This is the tricky and painful part of the process, as you are effectively decomissioning your previous PGP/GPG ID, loosing the created web of trust around it.

In order to let the world know that your new key pair actually belongs to you without having to meet in person again, the standard procedure is to sign the new key with the old one and the other way around, establishing a hard trust link between them (this action could not have been done without access to the old secret key, so as far as anyone can tell, this two-way signature could only have been done by you).

Signing the new and old public keys

First of all, let’s check that both secret keys are available in our keyring:

$ gpg --list-secret-keys
/Users/dpecos/.gnupg/pubring.kbx
--------------------------------
sec   dsa1024 2002-11-11 [SC]
      F6D13162F2BEF65838F6C8E6BF3B5AFCD4480E60
uid           [  full  ] Daniel Pecos Martinez
uid           [  full  ] Daniel Pecos Martinez <dpecos@gmail.com>
uid           [  full  ] Daniel Pecos Martinez <me@danielpecos.com>
ssb   elg4096 2009-11-19 [E]

sec   rsa4096 2019-03-27 [SC]
      31EFB482E969EB74399DBBC5E881015C8A55678B
uid           [ultimate] Daniel Pecos Martinez <me@danielpecos.com>
uid           [ultimate] Daniel Pecos Martinez <dani@dplabs.io>
ssb   rsa4096 2019-03-27 [E] [expires: 2024-03-25]
ssb   rsa4096 2019-03-27 [S] [expires: 2024-03-25]

Now in order to establish trust between the new and the old keys, we have to sign each other. First let’s sign the new key with old one:

$ gpg --default-key F6D13162F2BEF65838F6C8E6BF3B5AFCD4480E60 --sign-key 31EFB482E969EB74399DBBC5E881015C8A55678B

sec  rsa4096/E881015C8A55678B
    created: 2019-03-27  expires: never       usage: SC
    trust: ultimate      validity: ultimate
ssb  rsa4096/89BF354A17A61CC5
    created: 2019-03-27  expires: 2024-03-25  usage: E
ssb  rsa4096/665E29633F97EF11
    created: 2019-03-27  expires: 2024-03-25  usage: S
[ultimate] (1). Daniel Pecos Martinez <me@danielpecos.com>
[ultimate] (2)  Daniel Pecos Martinez <dani@dplabs.io>

Really sign all user IDs? (y/N) y
gpg: using "F6D13162F2BEF65838F6C8E6BF3B5AFCD4480E60" as default secret key for signing

sec  rsa4096/E881015C8A55678B
    created: 2019-03-27  expires: never       usage: SC
    trust: ultimate      validity: ultimate
Primary key fingerprint: 31EF B482 E969 EB74 399D  BBC5 E881 015C 8A55 678B

    Daniel Pecos Martinez <me@danielpecos.com>
    Daniel Pecos Martinez <dani@dplabs.io>

Are you sure that you want to sign this key with your
key "Daniel Pecos Martinez" (BF3B5AFCD4480E60)

Really sign? (y/N) y

And then the other way around:

$ gpg --default-key 31EFB482E969EB74399DBBC5E881015C8A55678B --sign-key F6D13162F2BEF65838F6C8E6BF3B5AFCD4480E60

gpg: checking the trustdb
gpg: marginals needed: 3  completes needed: 1  trust model: pgp
gpg: depth: 0  valid:   2  signed:   1  trust: 0-, 0q, 0n, 0m, 0f, 2u
gpg: depth: 1  valid:   1  signed:   0  trust: 1-, 0q, 0n, 0m, 0f, 0u
sec  dsa1024/BF3B5AFCD4480E60
    created: 2002-11-11  expires: never       usage: SC
    trust: unknown       validity: full
The following key was revoked on 2009-11-19 by DSA key BF3B5AFCD4480E60 Daniel Pecos Martinez
ssb  elg2048/3FBD37D1977AB8A4
    created: 2002-11-11  revoked: 2009-11-19  usage: E
ssb  elg4096/0DE841998B4ADD00
    created: 2009-11-19  expires: never       usage: E
[  full  ] (1). Daniel Pecos Martinez
[  full  ] (2)  Daniel Pecos Martinez <dpecos@gmail.com>
[ revoked] (3)  Daniel Pecos Martinez <dani@netpecos.org>
[  full  ] (4)  Daniel Pecos Martinez <me@danielpecos.com>

Really sign all user IDs? (y/N) y
gpg: using "31EFB482E969EB74399DBBC5E881015C8A55678B" as default secret key for signing
User ID "Daniel Pecos Martinez <dani@netpecos.org>" is revoked.  Unable to sign.

sec  dsa1024/BF3B5AFCD4480E60
    created: 2002-11-11  expires: never       usage: SC
    trust: unknown       validity: full
Primary key fingerprint: F6D1 3162 F2BE F658 38F6  C8E6 BF3B 5AFC D448 0E60

    Daniel Pecos Martinez
    Daniel Pecos Martinez <dpecos@gmail.com>
    Daniel Pecos Martinez <me@danielpecos.com>

Are you sure that you want to sign this key with your
key "Daniel Pecos Martinez <me@danielpecos.com>" (E881015C8A55678B)

Really sign? (y/N) y

Let’s check that the new key has been properly signed:

$ gpg --list-sigs E881015C8A55678B
pub   rsa4096 2019-03-27 [SC]
      31EFB482E969EB74399DBBC5E881015C8A55678B
uid           [ultimate] Daniel Pecos Martinez <me@danielpecos.com>
sig 3        E881015C8A55678B 2019-03-27  Daniel Pecos Martinez <me@danielpecos.com>
sig          BF3B5AFCD4480E60 2019-03-27  Daniel Pecos Martinez
uid           [ultimate] Daniel Pecos Martinez <dani@dplabs.io>
sig 3        E881015C8A55678B 2019-03-27  Daniel Pecos Martinez <me@danielpecos.com>
sig          BF3B5AFCD4480E60 2019-03-27  Daniel Pecos Martinez
sub   rsa4096 2019-03-27 [E] [expires: 2024-03-25]
sig          E881015C8A55678B 2019-03-27  Daniel Pecos Martinez <me@danielpecos.com>
sub   rsa4096 2019-03-27 [S] [expires: 2024-03-25]
sig          E881015C8A55678B 2019-03-27  Daniel Pecos Martinez <me@danielpecos.com>

The lines containing:

sig          BF3B5AFCD4480E60 2019-03-27  Daniel Pecos Martinez

reflect a signature on a UID. BF3B5AFCD4480E60 is the sort ID of my old key.

Revoke old key pair

Now we have to effectively decomission the old key pair. For that, we have to generate a revocation certificate for it:

$ gpg -a --gen-revoke BF3B5AFCD4480E60 > BF3B5AFCD4480E60.rev

sec  dsa1024/BF3B5AFCD4480E60 2002-11-11 Daniel Pecos Martinez

Create a revocation certificate for this key? (y/N) y
Please select the reason for the revocation:
  0 = No reason specified
  1 = Key has been compromised
  2 = Key is superseded
  3 = Key is no longer used
  Q = Cancel
(Probably you want to select 1 here)
Your decision? 2
Enter an optional description; end it with an empty line:
> Superseeded by E881015C8A55678B
>
Reason for revocation: Key is superseded
Superseeded by E881015C8A55678B
Is this okay? (y/N) y
Revocation certificate created.

Please move it to a medium which you can hide away; if Mallory gets
access to this certificate he can use it to make your key unusable.
It is smart to print this certificate and store it away, just in case
your media become unreadable.  But have some caution:  The print system of
your machine might store the data and make it available to others!

And then import it to our keyring to actually revoke the key:

$ gpg --import BF3B5AFCD4480E60.rev
gpg: key BF3B5AFCD4480E60: "Daniel Pecos Martinez" revocation certificate imported
gpg: Total number processed: 1
gpg:    new key revocations: 1
gpg: marginals needed: 3  completes needed: 1  trust model: pgp
gpg: depth: 0  valid:   2  signed:   0  trust: 0-, 0q, 0n, 0m, 0f, 2u

$ gpg --list-secret-keys
/Users/dpecos/.gnupg/pubring.kbx
--------------------------------
sec   dsa1024 2002-11-11 [SC] [revoked: 2019-03-27]
      F6D13162F2BEF65838F6C8E6BF3B5AFCD4480E60
uid           [ revoked] Daniel Pecos Martinez
uid           [ revoked] Daniel Pecos Martinez <dpecos@gmail.com>
uid           [ revoked] Daniel Pecos Martinez <me@danielpecos.com>

sec   rsa4096 2019-03-27 [SC]
      31EFB482E969EB74399DBBC5E881015C8A55678B
uid           [ultimate] Daniel Pecos Martinez <me@danielpecos.com>
uid           [ultimate] Daniel Pecos Martinez <dani@dplabs.io>
ssb   rsa4096 2019-03-27 [E] [expires: 2024-03-25]
ssb   rsa4096 2019-03-27 [S] [expires: 2024-03-25]

And we’re done! Next step is to publish our changes to the world.

Publish to PGP servers

We have to publish our new key pair and also the revoked old key pair. I’ve published them to two separate PGP servers in order to speed up the spreading of the changes, but that’s not strictly necessary as the key servers sync between them from time to time.

$ gpg --keyserver hkp://pgp.mit.edu --send-keys BF3B5AFCD4480E60 E881015C8A55678B
gpg: sending key BF3B5AFCD4480E60 to hkp://pgp.mit.edu
gpg: sending key E881015C8A55678B to hkp://pgp.mit.edu

$ gpg --keyserver hkp://pgp.surfnet.nl --send-keys BF3B5AFCD4480E60 E881015C8A55678B
gpg: sending key BF3B5AFCD4480E60 to hkp://pgp.surfnet.nl
gpg: sending key E881015C8A55678B to hkp://pgp.surfnet.nl

Publish to Keybase

If you are a Keybase user, you should also publish your new key there:

$ keybase pgp select
You are selecting a PGP key from your local GnuPG keychain, and
will publish a statement signed with this key to make it part of
your Keybase.io identity.

Note that GnuPG will prompt you to perform this signature.

You can also import the secret key to *local*, *encrypted* Keybase
keyring, enabling decryption and signing with the Keybase client.
To do that, use "--import" flag.

Learn more: keybase pgp help select

#    Algo    Key Id             Created   UserId
=    ====    ======             =======   ======
1    4096R   E881015C8A55678B             Daniel Pecos Martinez <me@danielpecos.com>, Daniel Pecos Martinez <dani@dplabs.io>
Choose a key: 1
▶ INFO Generated new PGP key:
▶ INFO   user: Daniel Pecos Martinez <me@danielpecos.com>
▶ INFO   4096-bit RSA key, ID E881015C8A55678B, created 2019-03-27

Backup everything

Last step is to make a backup of our new key pair (and the old one if we didn’t already). We will encrypt the private key files before storing them, adding an extra layer of security in case these files are uploaded to a cloud storage or somewhere else not 100% under our control.

First the old key pair (public & secret):

$ gpg --export --armor BF3B5AFCD4480E60> BF3B5AFCD4480E60.pub
$ gpg --export-secret-keys --armor BF3B5AFCD4480E60 | gpg --symmetric --armor > BF3B5AFCD4480E60.sec

Latest command will ask you for a password 3 times: the first two correspond to the symmetric encryption and the password has to be exactly the same the first two times; third time corresponds to the key pair’s password (the one you set up while creating the new pair).

Now let’s backup the new key pair (also public & secret):

$ gpg --export --armor E881015C8A55678B > E881015C8A55678B.pub
$ gpg --export-secret-keys --armor E881015C8A55678B | gpg --symmetric --armor > E881015C8A55678B.sec

And also the revocation certificate that was generate during key creation:

$ cat ~/.gnupg/openpgp-revocs.d/31EFB482E969EB74399DBBC5E881015C8A55678B.rev |  gpg --symmetric --armor > E881015C8A55678B.rev
$ rm cat ~/.gnupg/openpgp-revocs.d/31EFB482E969EB74399DBBC5E881015C8A55678B.rev

When exporting and encrypting the secret keys, we must use a different password for the backup encryption than the key’s password, otherwise this extra layer won’t provide any security in case of a 3rd party trying to break the password.

Store your master key pair offline and remove it from your keyring - Laptop keys

Now that we have everything backed up, we should remove our master key from the day-to-day device and use only the previously generated subkeys. The process is a little bit tricky, but not really hard. First of all, let’s export the subkeys to a (encrypted) file:

$ gpg --export-secret-subkeys --armor E881015C8A55678B | gpg --symmetric --armor > E881015C8A55678B-subkeys.sec

Now we delete the master key from our keyring (public & private keys):

$ gpg --delete-secret-key E881015C8A55678B

gpg (GnuPG) 2.2.14; Copyright (C) 2019 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.


sec  rsa4096/E881015C8A55678B 2019-03-27 Daniel Pecos Martinez <me@danielpecos.com>

Delete this key from the keyring? (y/N) y
This is a secret key! - really delete? (y/N) y

$ gpg --delete-key E881015C8A55678B

gpg (GnuPG) 2.2.14; Copyright (C) 2019 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.


pub  rsa4096/E881015C8A55678B 2019-03-27 Daniel Pecos Martinez <me@danielpecos.com>

Delete this key from the keyring? (y/N) y

And finally we import back just the subkeys. First the secret part:

$ cat E881015C8A55678B-subkeys.sec | gpg --decrypt | gpg --import
gpg: AES encrypted data
gpg: encrypted with 1 passphrase
gpg: key E881015C8A55678B: public key "Daniel Pecos Martinez <me@danielpecos.com>" imported
gpg: To migrate 'secring.gpg', with each smartcard, run: gpg --card-status
gpg: key E881015C8A55678B: secret key imported
gpg: Total number processed: 1
gpg:               imported: 1
gpg:       secret keys read: 1
gpg:   secret keys imported: 1
gpg: no ultimately trusted keys found

and then the public:

$ cat E881015C8A55678B.pub| gpg --import
gpg: key E881015C8A55678B: "Daniel Pecos Martinez <me@danielpecos.com>" not changed
gpg: Total number processed: 1
gpg:              unchanged: 1

Lastly we have to reset trust to ultimate for the imported subkeys:

$ gpg --edit-key 31EFB482E969EB74399DBBC5E881015C8A55678B
gpg (GnuPG) 2.2.14; Copyright (C) 2019 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

Secret subkeys are available.

pub  rsa4096/E881015C8A55678B
    created: 2019-03-27  expires: never       usage: SC
    trust: unknown       validity: unknown
ssb  rsa4096/89BF354A17A61CC5
    created: 2019-03-27  expires: 2024-03-25  usage: E
ssb  rsa4096/665E29633F97EF11
    created: 2019-03-27  expires: 2024-03-25  usage: S
[ unknown] (1). Daniel Pecos Martinez <me@danielpecos.com>
[ unknown] (2)  Daniel Pecos Martinez <dani@dplabs.io>

gpg> trust
pub  rsa4096/E881015C8A55678B
    created: 2019-03-27  expires: never       usage: SC
    trust: unknown       validity: unknown
ssb  rsa4096/89BF354A17A61CC5
    created: 2019-03-27  expires: 2024-03-25  usage: E
ssb  rsa4096/665E29633F97EF11
    created: 2019-03-27  expires: 2024-03-25  usage: S
[ unknown] (1). Daniel Pecos Martinez <me@danielpecos.com>
[ unknown] (2)  Daniel Pecos Martinez <dani@dplabs.io>

Please decide how far you trust this user to correctly verify other users' keys
(by looking at passports, checking fingerprints from different sources, etc.)

  1 = I don't know or won't say
  2 = I do NOT trust
  3 = I trust marginally
  4 = I trust fully
  5 = I trust ultimately
  m = back to the main menu

Your decision? 5
Do you really want to set this key to ultimate trust? (y/N) y

pub  rsa4096/E881015C8A55678B
    created: 2019-03-27  expires: never       usage: SC
    trust: ultimate      validity: unknown
ssb  rsa4096/89BF354A17A61CC5
    created: 2019-03-27  expires: 2024-03-25  usage: E
ssb  rsa4096/665E29633F97EF11
    created: 2019-03-27  expires: 2024-03-25  usage: S
[ unknown] (1). Daniel Pecos Martinez <me@danielpecos.com>
[ unknown] (2)  Daniel Pecos Martinez <dani@dplabs.io>
Please note that the shown key validity is not necessarily correct
unless you restart the program.

gpg> save
Key not changed so no update needed.

Let’s double check that we don’t have the master key available in our keyring, just the subkeys. If we try to edit the master key:

$ gpg --edit-key 31EFB482E969EB74399DBBC5E881015C8A55678B
gpg (GnuPG) 2.2.14; Copyright (C) 2019 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

Secret subkeys are available.

pub  rsa4096/E881015C8A55678B
    created: 2019-03-27  expires: never       usage: SC
    trust: ultimate      validity: ultimate
ssb  rsa4096/89BF354A17A61CC5
    created: 2019-03-27  expires: 2024-03-25  usage: E
ssb  rsa4096/665E29633F97EF11
    created: 2019-03-27  expires: 2024-03-25  usage: S
[ultimate] (1). Daniel Pecos Martinez <me@danielpecos.com>
[ultimate] (2)  Daniel Pecos Martinez <dani@dplabs.io>

We’ll see the message:

Secret subkeys are available.

Meaning that we won’t be able to create new subkeys, revoke, …:

gpg> addkey
Need the secret key to do this.

$ gpg --gen-revoke 31EFB482E969EB74399DBBC5E881015C8A55678B
gpg: secret key "31EFB482E969EB74399DBBC5E881015C8A55678B" not found: No secret key

For those critical operations we will have to import the backed up master key. For business as usual operations, subkeys are good enough, and if we loose them, we can restore the master key, revoke the subkeys and generate a new set, without our changing PGP/GPG ID and thus loosing the established trust.

Links

This tutorial is based on information gathered from the following links:

Demistifying blockchain - Part 2

Thu, 15 Nov 2018 23:10:00 +0100

In the previous post we explained from a theoretical point of view how a block chain works. In this post we will get down to work and will implement a working blockchain in Go.

If you haven’t read it yet, we recommend you to do it now before continuing. It’ll provide you the basic concepts needed to understand the examples below.

(You can find the complete example in this Github repository: https://github.com/dplabs/demistifying-blockchain)

First of all, let’s define what a block looks like for us:

type Block struct {
  Number int
  Timestamp time.Time
  Data string
  Nonce int
  Hash string
  Previous string
}

https://github.com/dplabs/demistifying-blockchain/blob/master/block.go#L14

Where:

Number: is used to identify a block in the chain. In our case it will be the position this block has in the chain. Note that the attribute is just used to have a user friendly reference to the block, not to actually link blocks between them.
Timestamp: when this block was created.
Data: the actual information this block contains.
Nonce: field used to for the hash of the block to meet certain rules. More on this later.
Hash: the result of applying a cryptographic hash function to this block. It has to take into account all the fields in the block (but Hash itself) in order to be able to detect tampering attempts to its content.
Previous: hash of the previous block in the chain. This is the actual field linking blocks in the chain (and in our example, also the position in the array of blocks).

Now let’s define an structure that will help us handle the block chain:

type BlockChain struct {
	Blocks    map[string]*Block
	Challenge string
	LastBlock *Block
}

https://github.com/dplabs/demistifying-blockchain/blob/master/blockchain.go#L8

Where:

Blocks: is the actual collection of blocks. Contiguous blocks are stored in contiguous positions in the array, although this is just an implementation detail, because the actual linkage should be done referencing their hashes.
Challenge: represents the level of difficulty the resulting hash has to meet in order to be considered valid. In our case we will say a block has is valid if it starts with the Challenge substring. The longer this challenge is, the hardest and more time consuming mining a block would be.
LastBlock: is a pointer to the latest block added to the chain, used to make computation easier.

So far we have presented two quite interesting fields: Nonce for a Block, and Challenge for a BlockChain, and the deserve a more in depth explanation. But first let’s talk about what a valid hash or signature for a block is, and for that we have to talk a little bit about Bitcoin.

When Bitcoin was designed, in order to achieve value as a coin, the concept of scarcity had to be taken into consideration: if a resource is easy to get, probably it won’t be valuable at all. The more difficult or unique the resource is, the more value people will give it. But being a digital currency, this was a not easy to solve challenge.

That’s how the concept of mining a block came into the picture: same way as gold is extracted from the ground (with lots of effort), a block has to require a lot of (artificial) effort to be added to the chain. Whomever manages to first mine a block, gets rewarded with coins in exchange for his effort.

In Blockchain, mining a block consist on calculating its hash, as we have explained. But usually hash functions are quite fast, so in order to make it harder (and thus create scarcity), a valid hash has to comply with a set of rules. In our implementation, the rule we’ve chosen is that the resulting hash has to begin with the Challenge substring defined while initializing the chain.

So in order to mine a block in our chain, the resulting signature of a block has to start with a certain string (in our example we’ve chosen it to be '0000'). So the algorithm for mining a block would first calculate current hash of the block and if the results fits the criteria of a valid hash, then we could add a successfully mined block to the chain. Otherwise we would have to change something in the block and repeat the process, and this is important, because if we don’t change anything in the block, the resulting hash will be the same. And thats what Nonce field is for. We will increment this number on every attempt to get a valid hash, until when eventually, we will get a hash matching the criteria. That’s why the longer the Challenge string is, the harder to mine a block will be.

func (block *Block) Mine(challenge string) string {

	fmt.Printf("Mining block %d... ", block.Number)

	tsStart := time.Now()

	block.Hash = ""
	block.Nonce = -1

	for done := false; !done; done = strings.HasPrefix(block.Hash, challenge) {
		block.Nonce = block.Nonce + 1
		block.Hash = calculateHash(block)
	}

	tsEnd := time.Now()
	elapsedTime := tsEnd.Sub(tsStart)

	p := message.NewPrinter(language.English)
	p.Printf("Valid hash found in %s! (hash: %s, nonce: %d)\n", elapsedTime.String(), block.Hash, block.Nonce)

	return block.Hash
}

https://github.com/dplabs/demistifying-blockchain/blob/master/block.go#L27

As you can see in the following execution of our demo, it takes between 10 and 30 seconds to find a valid hash (starting with ‘0000’) for every block. If you try this yourself, you will get different results as the timestamp of a block is taken into consideration for mining it (https://github.com/dplabs/demistifying-blockchain/blob/master/block.go#L51):

$ go run .
Blockchain initialized with challenge '0000'

Mining block 0... Valid hash found in 10.943824518s! (hash: 0000ociyEZOQk8ekRZ5VXcNJPLY=, nonce: 18,158,423)
Mining block 1... Valid hash found in 11.316462656s! (hash: 0000Dk0duKeCCHvDKuyFepXgUNc=, nonce: 15,208,609)
Mining block 2... Valid hash found in 28.805735271s! (hash: 0000O104QmKwfp2tVJ2JowVd9DI=, nonce: 37,840,116)

Resulting blockchain (in reversed order):

Block 2: {
   ts:          2018-11-10 15:17:40.602154 +0100 CET m=+22.260933223
   nonce:       37840116
   hash:        0000O104QmKwfp2tVJ2JowVd9DI=
   previous:    0000Dk0duKeCCHvDKuyFepXgUNc=
}

Block 1: {
   ts:          2018-11-10 15:17:29.285761 +0100 CET m=+10.944444407
   nonce:       15208609
   hash:        0000Dk0duKeCCHvDKuyFepXgUNc=
   previous:    0000ociyEZOQk8ekRZ5VXcNJPLY=
}

Block 0: {
   ts:          2018-11-10 15:17:18.341964 +0100 CET m=+0.000555870
   nonce:       18158423
   hash:        0000ociyEZOQk8ekRZ5VXcNJPLY=
   previous:
}

We encourage you to play with this code. You can download from the repository and compile and execute it yourself: https://github.com/dplabs/demistifying-blockchain

In the following and last post of this series, we will implement some benchmarks to analyze how much time it requires to mine a block based on the difficult we set.

Demistifying blockchain - Part 1

Sat, 10 Nov 2018 16:30:00 +0100

Blockchain is one of those buzzwords everyone is listening nowadays, but what it really is?

In this series of posts we will dig one general concepts about BlockChain and a little bit of its relation with BitCoin, as well as we will develop a simple blockchain in Go.

To put it simple, and as its name states, it’s just a chain of blocks. The interesting detail is that is a cryptographic chain providing some characteristics that make them really useful:

Tamper-proof
Distributed
Decentralized

We say a blockchain is tamper-proof because once a block has been added to the chain, nobody can modify it without also modifying its signature or cryptographic hash. But what if the attacker would also modify the signature to make it match its new content? A block stores as part of its data, the signature of the previous block in the chain (and that’s why it’s a chain), so if an attacker would try to replace a block in the chain (even using the correct cryptographic signature), would have to cascade the changes across all blocks from that one on until the end of the chain.

Even though, that’s a plausible attack scenario. How can BlockChain avoid it? Making the chain distributed and decentralized, so an attacker trying to modify the chain, would have to modify all instances ot the chain distributed across the world. And it has to be done at once to more than 50% of the nodes in the network, because being a decentralized network means that there is no golden copy of the chain. All instances in the network are equal.

This also means that whenever someone tries to attach a new node to the end of the chain, the network has to agree to that action. Once the network has acknowledged or achieved consensus, the new block is considered permanently and successfully added to the chain.

These characteristics are what make the Blockchain a secure, read-only and distributed database.

BlockChain is in the bare-bones of Bitcoin, as the cryptocurrency uses a blockchain implementation as the public ledger system, and thus since the boom of cryptocurrencies, this type of databases have caught the interest of more and more researchers and developers.

In the following video you will find a more detailed explanation of what we want to implement in this series of posts. If the concept of what a block chain is is still not clear, please have a look to the video before going further in the series:

In the following post we will start implementing our own blockchain in Go, as well as going more in detail into the characteristics of block mining.

Web Mining: is that bad?

Wed, 25 Oct 2017 09:20:46 +0100

There has been a lot of noise around Monero and Coinhive lately, or web mining in general, and don’t quite agree with most of what I’m hearing.

It all started with The Pirate Bay adding a web mining script to their site, so whenever you’d visit them, your CPU would be used to mine some Monero for them. That was made without any notice to the user, just “stealing” their power. That was probably the best ad Coinhive (which is the service hosting the mining script and providing the required infrastructure to mine Monero) could get, as it appeared all over the news (even some local newspaper got noticed). And, as it was to expect, plenty of sites added the same piece of script so they could also benefit from their users base.

But something really interesting followed to this: most ad-block extensions started to block Coinhive, frustrating all the efforts of these people getting reach.

Let’s stop for a second and analyze what happened:

Website owners use their users’ computers to mine (earn) some (crypto-) money.
Ad-blockers think that’s an abuse and not legitimate and start blocking that mining.
Lots of news about how evil these people are written all over the internet.

Really? So I, as a content creator, willingly giving that content to the community, am an evil person for trying to monetize that content / time with the cost of the electricity the user spends while being on my site. Because everything on Internet must be free of cost, and those evil people trying, not to live from it, but just to get a little money for their time, should be ashamed of even trying.

Well, a similar thing happened with ads, and when sites started abusing of them, making the user experience a pain, is when ad blockers started flourishing, and well-behaved content creators getting their incomes cut. And the same should happen to those who mine under the hood, without the user approval, or those who mine using too much CPU time, making user’s computer unusable.

But we have not given yet the chance to make of web mining a legitimate way to monetize content. And why? Probably not because you’re abusing your users CPU or because users are not aware, but because you’re making money without taking into account Adsense or other gigantic ad platforms that could run into serious problems if this becomes a trend.

Why otherwise would Chrome’s team have worried so much and so fast about this, proposing even the creation of a throttle down inside the browser itself?

I don’t think this recent noise is all about mining itself but about those ad platforms losing their control over Internet content monetization.

Note: as you would probably have noticed when loaded this post, a popup appeared asking for your permission to mine using your CPU. It’s totally up to you to decide if should get some of your time or not.

REST API with Node.js and Swagger

Tue, 05 Sep 2017 22:07:29 +0100

In this tutorial I’ll show how to piece together the required NPM modules to build a REST API in Node.js with proper Swagger documentation. We’re going to use Express as the HTTP framework, and the Swagger documentation will be written as inline comments within the code, as close as possible to the handling endpoint or models that will implement the contract, so it will be harder for them to eventually diverge.

First of all, these are the main modules we are going to use:

swagger-jsdoc to extract the documentation from the comments in the source code
swagger-ui-express to build on-the-fly an HTML version of the documentation (which will allow us also to live test it)
swagger-model-validator to check that the input & outputs of the request match the models defined for the endpoints

Let’s start with the handlers for the REST endpoints:

// api/controllers/stocks.js

router.get('/', (req, res, next) => {
  const response = dao.retrieveAll()
  res.send(response)
})

router.get('/:id', (req, res, next) => {
  const response = dao.retrieve(parseInt(req.params.id, 10))
  res.send(response)
})

router.put('/:id', (req, res, next) => {
  const response = dao.update(parseInt(req.params.id, 10), req.body.lastUpdate)
  res.send(response)
})

router.post('/', (req, res, next) => {
  const response = dao.create(req.body)
  res.send(response)
})

Nothing especial hear, just plain Express handlers, using GET, PUT and POST HTTP verbs.

Now let’s write the Swagger documentation as JSON documents within JS multiline comments:

// api/models/stock-model.js

/**
 * @swagger
 * definitions:
 *   Stock:
 *     type: object
 *     required:
 *       - id
 *       - name
 *       - currentPrice
 *       - lastUpdate
 *     properties:
 *       id:
 *         type: number
 *       name:
 *         type: string
 *       currentPrice:
 *         type: number
 *       lastUpdate:
 *         type: number
 *   Stocks:
 *     type: array
 *     items:
 *       $ref '#definitions/Stock'
 */
export default class Stock {
  constructor (id, name, currentPrice, lastUpdate) {
    this.id = id
    this.name = name
    this.currentPrice = currentPrice
    this.lastUpdate = lastUpdate
  }
}

// api/controllers/stocks.js

/**
 * @swagger
 * /stocks:
 *   get:
 *     description: Retrieve the full list of stocks
 *     tags:
 *       - stocks
 *     produces:
 *       - application/json
 *     responses:
 *       200:
 *         description: stocks
 *         schema:
 *           $ref: '#/definitions/Stocks'
 */
router.get('/', (req, res, next) => {
  const response = dao.retrieveAll()
  res.send(response)
})

/**
 * @swagger
 * /stocks/{id}:
 *   get:
 *     description: Retrieve an specific stock
 *     tags:
 *       - stocks
 *     produces:
 *       - application/json
 *     parameters:
 *       - name: id
 *         description: id of the stock to retrieve
 *         in: path
 *         required: true
 *         type: number
 *     responses:
 *       200:
 *         description: stock
 *         schema:
 *           $ref: '#/definitions/Stock'
 */
router.get('/:id', (req, res, next) => {
  const response = dao.retrieve(parseInt(req.params.id, 10))
  res.send(response)
})

...

Now that we have all the documentation in place, let’s define a new endpoint to serve the live documentation:

// api/controllers/swagger.js

const options = {
  swaggerDefinition: {
    info: {
      title: 'REST - Swagger',
      version: '1.0.0',
      description: 'REST API with Swagger doc',
      contact: {
        email: 'contact@danielpecos.com'
      }
    },
    tags: [
      {
        name: 'stocks',
        description: 'Stocks API'
      }
    ],
    schemes: ['http'],
    host: 'localhost:3000',
    basePath: '/api'
  },
  apis: ['./api/controllers/stocks.js', './api/models/stock-model.js']
}

const swaggerJSDoc = require('swagger-jsdoc')
const swaggerUi = require('swagger-ui-express')
const swaggerSpec = swaggerJSDoc(options)

router.get('/json', function (req, res) {
  res.setHeader('Content-Type', 'application/json')
  res.send(swaggerSpec)
})

router.use('/', swaggerUi.serve, swaggerUi.setup(swaggerSpec))

As you can see in the next screenshot, the docs are live and working against the endpoints served by the same application:

And you can even test them in realtime!

Finally let’s put some code that will allow us to check that the inputs & outputs of the different endpoints match the models defined in Swagger:

// api/controllers/stocks.js
...
router.put('/:id', (req, res, next) => {
  Swagger.validateModel('TimeStamp', req.body)
  const response = dao.update(parseInt(req.params.id, 10), req.body.lastUpdate)
  Swagger.validateModel('Stock', response)
  res.send(response)
})
...

Now we have a proper (and documented) REST API that we can hand over to any developer, making her life easier and more productive.

You can find this example in this GitHub repository:

https://github.com/dpecos/rest-swagger-example

From Ubuntu to Arch Linux

Wed, 24 May 2017 20:57:44 +0100

Recently I took the decision of leaving my long beloved distro – Ubuntu (sorry, link in spanish) and moving forward into Arch Linux.

And why? As JFK said when the USA was aiming to land on the moon, “not because it’s easy, but because it’s hard”, maybe not that much compared to getting to the moon, but definitely more tedious than Ubuntu. One thing you can take for sure if you take the chance to install Arch: no matter if you success or give up with it, you will learn something new about how a Linux distro works.

But really, why? Well, the announcement of retiring Unity 8 from Ubuntu from version 18.04 was the trigger to explore other desktop options. I started testing Gnome 3 (which is going to be the official replacement for Unity) but it didn’t make me fall in love with it. Then I tried XFCE but it was too simple, way to much. Finally I tried Plasma (former KDE Desktop) and I got impressed. Since I switched to Ubuntu back in 2008, I’ve been using Gnome 2 or Unity based desktops and never got too curious about trying anything else. Plus, installing KDE always required tons of extra libraries that would be probable be left out in the system after an eventual removal of the desktop environment (and the screenshots and feedback I read for KDE 4 were really discouraging).

But Plasma look & feel was really slick. And, after digging a little bit about latest events in the KDE / Qt community, finally decided to completely move to Plasma, specifically to latest version available in Ubuntu 17.04, Plasma 5.8.

And then I saw a review of Plasma 5.9, introducing some improvements over previous version and decided to test it, so I looked for a PPA to install it in Ubuntu, but there was none available 🙁

What could I do to get the latest version working in my desktop? I could have waited for a while until it would eventually made it into a PPA. Or I could try a rolling distro 😉 And this is when Arch ringed a bell. Maybe this was the opportunity to give it a chance and try the (tedious) installation process. And of course move to a totally different package system (pacman).

The first installation took me around a couple hours, going from a blank VM to a fully working Plasma desktop. Don’t get me wrong, I’m not saying it’s an easy process or meant to someone with little or none Linux experience: it requires some basic knowledge and experience in Linux systems to know what you’re doing (and not just blindly copying & pasting from the wiki) .

I have to confess: I’ve been hooked by Arch since then on, and decided to move all my desktop environments to Arch + Plasma. Although it has a quite steep learning curve, once you get familiar with pacman and any of the AUR package managers, it’s quite straight forward to get the packages you need installed and set up. And when you eventually face any problem then you discover the strong point of this distro: its documentation. It’s really amazing to see how many pages that wiki contains and how complete it is. It even has a page to setup Starcraft (which now is free!)

Nacidos de la Bruma III – El Héroe de las Eras – Mistborn

Wed, 30 Nov 2016 07:02:06 +0100

En El Héroe de las Eras, tercera y última entrega de la saga Nacidos de la Bruma – Mistborn, Brandon Sanderson nos presenta el colofón a esta épica historia de aventuras y magia – alomancia, en la que los protagonistas viajan a través del mundo en busca de las pistas que Lord Legislador les dejó para combatir el mal que les avecina: Ruina.

La Banda de Kelsier, encabezada por Vin y Lord Elend, tratarán de aunar las distintas ciudades del mundo en una lucha común contra las brumas, aunque no será una tarea fácil. Los restos de la iglesia de Lord Legislador y sus criaturas, se han diseminado por el mundo y, aunque sin ser lo fuertes que fueron cuando éste estaba gobernando, serán causa de gran multitud de problemas para nuestros protagonistas.

En esta entrega podemos ver cómo Brandon Sanderson, genio de la narrativa de ciencia ficción y épica fantástica, engrana gran cantidad detalles, en un principio nimios, para dar un cierre colosal a la historia, hacia el que todas las pequeñas tramas que se han ido mostrando durante la trilogía convergen, consiguiendo un final digno de la obra.

Como viene siendo habitual con este autor, el ritmo, la forma de describir el mundo y unos personajes que nos harán sentir partícipes de sus aventuras, son el común denominador de la historia, haciendo que la devoremos desde el primer momento, prácticamente sin darnos cuenta.

El Héroe de las Eras es el cierre de una obra de arte de la literatura de ficción contemporánea, considerada como uno de los imprescindibles del género por muchos. Política y Religión, temas subyacentes de la saga, hacen que su lectura sea apasionante e inmersiva, haciendo de esta entrega, y sobre todo de la saga Nacidos de la Bruma – Mistborn, una lectura obligatoria para los amantes de la temática.

Nacidos de la Bruma II – El Pozo de la Ascensión – Mistborn

Fri, 25 Nov 2016 06:30:06 +0100

El Pozo de la Ascensión es la segunda parte de la saga de Nacidos de la Bruma (Mistborn) de Brandon Sanderson, en la que ha demostrado que posee la creatividad suficiente para dar vida a una historia de gran envergadura, y lo mejor, conservando la esencia de la entrega anterior, añadiendo unos toques que proporcionan un aire de frescura y misterio a la franquicia.

Esta entrega se inicia con los problemas que nuestros protagonistas enfrentan tras conseguir su objetivo: la muerte de su enemigo, Lord Legislador, pero a un alto precio, el sacrificio de su líder Kelsier. Inestabilidad política encaminada a una guerra económica es el ambiente que se respira en el imperio, un destino nada previsto por los liberadores y que tratarán de evitar por todo lo posible.

Para ello entablarán alianzas con la nobleza donde encontrarán un inesperado aliado, Elend Venture, hijo de la casa más poderosa de Luthadel, pero difícil heredero de ésta. El interés principal de su padre no será precisamente el de una transición de poder pacífica.

Brandon Sanderson de nuevo nos presenta un mundo fantástico, con héroes con poderes alomáticos y, también, debilidades humanas. Como viene siendo habitual con este autor, es una obra dinámica, de fácil lectura y que engancha desde el primer minuto.

En resumen, El Pozo de la Ascensión, segunda parte de esta magnífica saga, Nacidos de la Bruma (Mistborn), es una obra trepidante y que sin duda nos sorprenderá y mantendrá en vilo en muchas ocasiones.

Nacidos de la Bruma I – El Imperio Final – Mistborn

Mon, 21 Nov 2016 07:00:30 +0100

Si lo que deseas es una trama absorbente, con una gran cantidad de misterio, situaciones fantásticas y personajes entrañables, El Imperio Final, primer libro de la saga Nacidos de la Bruma – Mistborn de Brandon Sanderson es estás buscando. Sin duda alguna es una historia que demuestra que aún es posible encontrar libros con un buen contenido literario y un tono oscuro, tan difícil de encontrar en la literatura fantástica desde hace mucho tiempo. Puede considerarse un digno sucesor de grandes libros épicos del estilo del Señor de los Anillos o Juego de Tronos, sin duda alguna, una joya que te recomiendo no perder.

Dentro de Nacidos de la Bruma – El Imperio Final, Brandon Sanderson nos introduce en un mundo muy diferente al habitual y especialmente sombrío en el cual nada florece y las cenizas son constantes, los ciudadanos se encuentran oprimidos por un tirano conocido como el Lord Legislador, que junto sus asociados, la iglesia y la clase alta, controlan el metal más preciado de la alomancia: el Atium, extraído lenta y dolorosamente de los Pozos de Hathsin.

Los skaa, la clase obrera controlada y explotada por los nobles, son el motivo por el cual los protagonistas, Kelsier y Vin, pelearán contra los tiranos para conseguir que se les libere de su tormento. Ambos nacidos de la sombra, reunirán un grupo de alómanticos que les ayudarán a conseguir sus objetivos.

En Nacidos de la Bruma – El Imperio Final nos encontramos con una historia llena de acción repleta de personajes que van evolucionando a lo largo de la misma, donde es posible observar traición, amor, duda, proezas épicas, y supervivencia todo con tal de lograr liberarse del yugo por el cual se encuentran oprimidos los skaa, con un desenlace trepidante y que hará que saltes a por la segunda parte de esta magnífica saga.

Elantris

Thu, 17 Nov 2016 07:05:58 +0100

La ciudad de los dioses ya no es un lugar con seres de grandes poderes y magia, es ahora un lugar en ruinas llena de no muertos que sufren incansablemente por un hambre sobrehumana, dolores que nunca sanan y un corazón que no late. Elantris de Brandon Sanderson es la ciudad donde una misteriosa desgracia cambió todo, sus habitantes se transformaron y después de ser unas maravillas, son ahora seres malditos. Esta novela llena de fantasía y acción presenta la historia de tres personajes, el príncipe Raoden (quién sufrió la transformación), la princesa Sarene y el sacerdote Hrathenun.

Elantris el lugar de los dioses ahora es la tierra de los “no vivos”

Existe una magia en Elantris de Brandon Sanderson, quizás los Aones están relacionados con la catástrofe que cambió el curso del reino de Arelon. La población aún no asume el cambio tan grande que ocurrió en su tierra, cuál fue la causa de tanta desesperanza y sufrimiento.

Mucho sufrimiento para los No vivos, la aristocracia tiene un poder que sobrepasa los derechos de los ciudadanos, la anarquía y el hambre inacabable predominan en la lucha de los habitantes. Elantris de Brandon Sanderson muestra la intención de la religión para conquistar el poder absoluto, el sacerdote Hrathenun utiliza artimañas para hacer que la corrupción, los vicios e intereses personales perturben el amor de los príncipes para dominar el reino a través de su secta.

En Elantris el príncipe Raoden luego de ser el heredero del reino, sufre el mal de Shaod provocando su exilio en la tierra de los no muertos, al parecer la transformación no es por completo, poco a poco va sintiendo que se apodera de sus sentidos, inicia una guerra interna con sus recuerdos y el presente.

El amor de Sarene y Raoden los príncipes de “Elantris”

La energía que mantiene viva a la ciudad representa un factor importante en la vida de Raoden, quien a lo largo de la historia analiza y trata de comprender la finalidad de los Aones en la vida de los Elantrinos. El pretexto recibir a los no muertos como maravillas logró que los trasladaran, al llegar a la ciudadela la realidad es otra, son encarcelados, obligados a una vida sin final y tomados como no vivos por los que no han sido afectados por el Shaod.

Sarene, la novia política de Roaden, tiene el dilema de amar y respetar a su príncipe muerto o seguir las recomendaciones del sacerdote Hrath, casarse con otro hombre. Esta elección altera rápidamente el curso del amor y amenaza con el destino de los habitantes de Arelon. El reino se ve amenazado por la decisión que tome la princesa, casarse nuevamente o no.

Una trama que mantiene el misterio de principio a fin, situaciones llenas de controversia en un régimen político amenazado por una desgracia, el interés religioso, el amor inalcanzable entre los príncipes, la búsqueda del significado de los Aones y la trasformación de Raoden hacen de Elantris de Brandon Sanderson una revolucionaria novela de ficción, fantasía y amor.

Gracias Mamá

Tue, 15 Nov 2016 07:01:12 +0100

Por todo lo que has sido y hecho, no puedo hacer otra cosa que estarte agradecido.

Llevo meses tratando de escribir este post, y realmente puede que sea el más difícil escrito nunca. Varias veces he tenido que parar y dejarlo para otro momento. No pretendo que sea un post público sino algo que te escribo a ti. Para mi.

Ni que decir que te echaré de menos. Nunca te olvidaré y haré todo lo posible para que Izan tampoco lo haga. Todas las noches mira las estrellas para mandarte besos.

Gracias por todo mamá!

El Temor de un Hombre Sabio

Mon, 14 Nov 2016 07:00:46 +0100

El ex profesor de lengua y literatura inglesa Patrick Rothfuss presenta El Temor de un Hombre Sabio la continuación del libro El Nombre del Viento, incluido en la Crónica el Asesino de Reyes. Narra la historia de un joven prodigio que todos dan por muerto, ahora con nuevo nombre en una aldea extraviada, trata de rehacer y continuar con su vida. Los recuerdos sobre interesantes batallas, alegrías y penurias explican porque la arrogancia y seguridad en la actitud de Kvothe, “Quizás hayas oído hablar de mí”.

Kvothe vuelve con heroísmo y penurias en “El Temor de un Hombre Sabio”

Kvothe sigue siendo el héroe, trotamundos y ladrón acostumbrado, su pasado lo persigue a través de sus recuerdos. No puede culminar sus estudios, recorre los paisajes de Severen, allí se vincula a la política de la sociedad cortesana. Una interesante, pero peligrosa mujer aparece, Felurian, quien logra seducirlo con mucha sensualidad a través de sus encantos. Tanto así que la acompaña sin pensarlo al mundo de los Fatas ese del cual nadie regresa, creando muchas circunstancias amorosas en la vida del joven.

Poco a poco se vuelve buen asesino, cualidad incondicional para lograr su venganza contra los Chandrian. En El Temor de un Hombre Sabio Kvothe cuenta con la compañía de Tempi, un mercenario Adem. Aprende el legendario ketan, en esta oportunidad se suman enseñanzas y misiones que fortalecen sus conocimientos en combate.

“El hombre había desaparecido, el mito había quedado”

El Temor de un Hombre Sabio empieza donde termina** El Nombre del Viento**. Mundos de tinieblas y oscuridad, donde Kvothe se ve maduro, argumenta sus decisiones, posee dinero, empieza a asumir responsabilidades en la espontánea vida que ha llevado. Aparecen nuevamente sus amigos, se reencuentra con todos ellos y nacen nuevas tertulias y anécdotas que comprueban porque hay rebeldía, irreverencia a los lujos y fuerte lucha contra la pobreza en la vida del trotamundos.

Es un nuevo joven, rebelde, pero comienza a comprender la responsabilidad de su poder, está más enfocado en la venganza, se mantiene bajo perfil ahora planea sus acciones. Sin embargo aparecen nuevas cadenas que romper y decisiones que tomar para este casi adulto.

“He recorrido de noche caminos de los que otros no se atreven a hablar ni siquiera de día”. En **El Temor de un Hombre Sabio **la arrogancia es fiel compañera de Kvothe, el enemigo interno resulta en ocasiones más poderoso que la voluntad, la cualidad de héroe se resalta y comprueba con las habilidades adquiridas desde niño hasta el presente.

**El Temor de un Hombre Sabio **es la obra de ficción fantasía que trasmite realidad en un mundo lleno de magia, dioses, clasismo y la ideología Teccam, creíble y cierta para Kvothe. El destino depara mundos nuevos, costumbres sociales diferentes y distintos sistemas monetarios al cual debe adaptarse para poder pasar inadvertido ante los problemas. La premisa de venganza se mantiene y el miedo no es la mejor opción. “Todo hombre sabio teme tres cosas: la tormenta en el mar, la noche sin luna y la ira de un hombre amable”.

El Nombre del Viento

Mon, 07 Nov 2016 07:00:50 +0100

Asesino, músico, mendigo, estudiante, ladrón, mago y héroe: ésta es la verdadera historia de Kvothe. Tras soportar los cotilleos, rumores y conjeturas que las personas hicieron sobre su vida, en El Nombre del Viento se narra las verdaderas vivencias de su auténtica y dificultosa existencia en el mundo.

Se trata de una novela llena de fantasía escrita por el estadounidense Patrick Rothfuss, su primera edición fue en 2011 y hoy en día cuenta con muy buenos comentarios de críticos en todo el mundo. Este libro ganó el Premio Pluma al mejor libro en el género de literatura fantástica, lo cual representó un impulso para que su autor se dedicara con más pasión a la escritura.

“He recorrido de noche caminos de los que otros no se atreven a hablar ni siquiera de día. He hablado con dioses, he amado a mujeres y he escrito canciones que hacen llorar a los bardos. Me llamo Kvothe. Quizá hayas oído hablar de mí.”

Después de tanto, en esta historia Kvothe narra la verdad sobre sí mismo. Ante todo lo que ha pasado, siempre debe haber un comienzo: su infancia con sus padres en una troupe. Durante sus años de crecimiento y gracias a su familia, se encuentra constantemente relacionado con la actuación, la música, los juglares y la acrobacia.

Debido a este ambiente artístico donde pasó la mayor parte de su vida, Kvothe se convirtió en un niño con mucho talento para la música y los cuentos, además todos lo conocían como una persona diplomática, alegre y muy servicial.

Viajé, amé, perdí, confié y me traicionaron

El nombre del viento cuenta de manera detallada los años de Kvothe malviviendo como ladrón en la gran ciudad, cometiendo pequeños y grandes crímenes que le dan rumbos inesperados a la historia. Mediante pasan los años, el protagonista conoce a distintas personas que se vuelven parte importante de la historia.

Después de distintos retos y acontecimientos, el protagonista de esta historia viaja a la universidad, un reconocido centro de educación mágica donde lograr encontrar muchas de las respuestas que había estado buscando hacía tanto tiempo; este centro de formación es para personas con dinero y poder adquisitivo, lo que le dificulta su aprendizaje y su estadía en el lugar.

“He robado princesas a reyes agónicos. Incendié la ciudad de Trebon. He pasado la noche con Felurian y he despertado vivo y cuerdo. Me expulsaron de la Universidad a una edad a la que a la mayoría todavía no los dejan entrar”

El libro tiene dos líneas temporales diferentes: el pasado narrado por Kvothe, basados en sus recuerdos y vivencias memorables; y el presente, narrado en tercera persona. La novela pese a tantos acontecimientos inesperados, se desarrolla en un solo día.

Desde su lanzamiento, esta historia ha causado un impacto positivo en los críticos literarios y los amantes del género fantástico; finalmente, después de tantas especulaciones y rumores, en el nombre del viento se narra los sucesos reales y la verdadera historia de Kvothe.

Plan de ahorro personal

Mon, 07 Nov 2016 06:45:47 +0100

Tras unos días de análisis e introspectiva financiera, he conseguido detallar cuáles son mis gastos previsibles mes a mes, por lo que creo que me encuentro en situación de pasar a la siguiente fase: definir un plan de ahorro personal.

Voy a optar por un plan bastante agresivo, puesto que mi colchón actual está completamente deshinchado y esto es algo que me hace sentir poco seguro. Tras hablarlo con mi mujer, hemos decidido apretarnos un poco el cinturón con el fin de poder corregir esta situación. Así que nos hemos fijado como objetivo ahorrar el 25% de nuestro salario cada mes. Una vez alcancemos la cantidad de 2000€ en líquido, el resto de los futuros ahorros los invertiremos en bolsa a largo plazo y plazos fijos. No tengo todavía claro en qué porcentaje, pero todavía tengo tiempo disponible para pensarlo.

Comprobando el balance financiero personal que desarrollé, durante 5 de los 12 meses nuestro disponible mensual se queda por debajo de este 25% del salario, a veces por mucho y otras veces por menos. Para los otros 7 meses, por lo normal el disponible es bastante mayor al porcentaje de ahorro, por lo que espero poder compensar unos meses con otros. ¿Cómo? Teniendo unos 2000€ líquidos siempre en cuenta, de forma que en los meses que el ahorro del 25% se cubra íntegramente con el salario del mes, hincharé el colchón con el resto disponible en en líquido para poder complementar el salario de los meses más duros y así conseguir la meta del 25% todos los meses.

Siguiendo el objetivo inicial de esta página, voy a tratar de publicar de forma periódica (seguramente trimestral) un pequeño análisis de cómo van estos objetivos, y ver cómo de cerca o lejos me encuentro de esta meta de ahorro.

Lo primero: reducir gastos superfluos, que gracias al balance financiero es muchísimo más fácil identificarlos ahora que cuando no disponía de esta herramienta. Además me permite focalizar esfuerzos en aquello que me va a generar un mayor retorno.

¡Manos a la obra!

Canción de Hielo y Fuego: Juego de Tronos: 1

Wed, 02 Nov 2016 07:00:06 +0100

Juego de Tronos (Game of Thrones) es una de las franquicias más exitosas de los últimos tiempos que combina batallas épicas, dinastías poderosas y todo un mundo místico que se cierne sobre sus personajes, llenos de emociones netamente humanas. La historia se desarrolla en un mundo ficticio medieval, en un continente llamado Poniente, donde se desenvuelve una historia llena de sucesos impresionantes, increíbles personajes y desenlaces totalmente inesperados. Se trata de Canción de Hielo y Fuego, escrita por George R. R. Martin, una novela que ha sido traducida a más de 30 idiomas desde su lanzamiento. El escritor comenzó a crear esta obra en 1993 y tiempo después, en 1996 fue publicado su primer tomo.

Después de un largo verano, los Siete Reinos se ven amenazados por un invierno devastador. El señor de Invernalia, Lord Eddard Stark debe emprender un viaje hacia Poniente con su viejo amigo el rey Robert Baratheon, abandonando sus dominios en Invernalia para ocupar el cargo de Mano de Rey en la capital.

Lord Stark en búsqueda de respuestas a una serie de intrigas sobre el reinado de Poniente, pone en riesgo su vida y la vida de sus familiares más cercanos. Sin embargo, detrás de distintos sucesos la historia se basa en tres líneas argumentales: la creciente amenaza de los Otros y los salvajes, la temida guerra civil dinástica por el control de la capital y el viaje de Daenerys Targaryen, la hija de un exiliado rey.

Estas tres historias son relacionadas de manera constante durante toda la narración de canción de hielo y fuego, transcurriendo de acuerdo a una serie de sucesos inesperados que cautivan a cualquier lector.

“La noche es oscura y alberga cosas aterradoras”

Los otros o conocidos en el Pueblo Libre como caminantes blancos, son criaturas que protagonizan de manera indirecta esta historia, forman parte importante de la historia y representan la mayor y más temida amenaza de los Siete Reinos.

La historia es narrada en tercera persona, permitiéndonos ver mediante los ojos y la posición de distintos personajes. En muchas escenas existen muestras claras de cómo la guerra por el poder y la conquista puede destruir familias y acabar con la vida de personas inocentes.

En la historia de canción de fuego y hielo, existen múltiples casas representadas con diferentes emblemas, sin embargo las 4 casas más importantes de toda la historia son: la casa Stark, la casa Baratheon, la casa Targaryen y la prestigiosa casa Lannister.

“Cuando se juega al juego de tronos sólo se puede ganar o morir. No hay puntos intermedios”

Al transcurrir la narración, se puede apreciar tanto la unión como el enfrentamiento entre estas y las demás casas nobles de Poniente; Canción de Hielo y Fuego no sólo se basa en extensos e increíbles personajes sino también en cambios de trama repentinos y violentos, argumentos políticos bien desarrollados y un manejo constante de géneros como la ciencia ficción, la fantasía erótica y el drama.

Esta novela es considerada como una de las obras más innovadoras de su género y ha logrado captar la atención de millones de personas en todo el mundo, incluso para el 2013, esta serie de novelas había alcanzado a más de 25 millones de personas.

PostGreSQL vs. MySQL

Sun, 30 Oct 2016 22:29:43 +0100

PostgreSQL vs. MySQL

Tabla de contenidos

Introducción
PostGreSQL

2.1. ¿Qué es postgresql?

2.2. Historia de PostGreSQL

2.3. Características de PostGreSQL

2.4. ¿Qué es lo que le falta?

2.5. Opinión Personal
MySQL

3.1. ¿Qué es MySQL?

3.2. Historia de MySQL

3.3. Características de MySQL

3.4. ¿Qué es lo que le falta?

3.5. Opinión Personal
Comparativa

4.1. Introducción

4.2. Lo mejor de PostGreSQL …

4.3. … y lo peor

4.4. Lo mejor de MySQL …

4.5. … y lo peor
Conclusión
Bibliografía

Hoy en día existen muchas empresas y sitios web que necesitan mantener de forma eficiente un gran volumen de datos. Muchos de ellos optan por soluciones comerciales, aunque muchas otras confían en el software libre optando por una solución como PostGreSQL o MySQL.

En este documento se tratará de hacer una comparativa entre los sistemas de gestión de bases de datos libres más importantes y más usados en la red, los cuales proporcionan soluciones a miles de personas, de forma totalmente gratuita, sin pérdida de eficiencia alguna.

1. Introducción

Común es la pregunta entre las personas que se adentran por primera vez en el mundo de las bases de datos libres: ¿MySQL o PostGreSQL? En realidad no es una pregunta asociada específicamente a los “novatos”, ya que incluso los profesionales dedicados a este campo se realizan muchas veces esta misma pregunta. La verdad es que no es una pregunta fácil de responder, y no carente de grandes controversias.

El objetivo de este documento será introducir las características de estos dos magníficos sistemas de gestión de bases de datos, haciendo una pequeña comparativa entre ellas, con el fin de conducir a la elección más adecuada para cada situación.

2. PostGreSQL

2.1. ¿Qué es PostGreSQL?

PostGreSQL es un sistema de gestión de bases de datos objeto-relacional (ORDBMS) basado en el proyecto POSTGRES, de la universidad de Berkeley. El director de este proyecto es el profesor Michael Stonebraker, y fue patrocinado por Defense Advanced Research Projects Agency (DARPA), el Army Research Office (ARO), el National Science Foundation (NSF), y ESL, Inc.

PostGreSQL es una derivación libre (OpenSource) de este proyecto, y utiliza el lenguaje SQL92/SQL99, así como otras características que comentaremos más adelante.

Fue el pionero en muchos de los conceptos existentes en el sistema objeto-relacional actual, incluido, más tarde en otros sistemas de gestión comerciales. PostGreSQL es un sistema objeto-relacional, ya que incluye características de la orientación a objetos, como puede ser la herencia, tipos de datos, funciones, restricciones, disparadores, reglas e integridad transaccional. A pesar de esto, PostGreSQL no es un sistema de gestión de bases de datos puramente orientado a objetos.

2.2. Historia de PostGreSQL

PostGreSQL (llamado también Postgres95) fue derivado del proyecto Postgres, como ya se ha comentado. A sus espaldas, este proyecto lleva más de una década de desarrollo, siendo hoy en día, el sistema libre más avanzado con diferencia, soportando la gran mayoría de las transacciones SQL, control concurrente, teniendo a su disposición varios “language bindings” como por ejemplo C, C++, Java, Python, PHP y muchos más.

La implementación de Postgres DBMS comenzó en 1986, y no hubo una versión operativa hasta 1987. La versión 1.0 fue liberada en Junio de 1989 a unos pocos usuarios, tras la cual se liberó la versión 2.0 en Junio de 1990 debido a unas críticas sobre el sistema de reglas, que obligó a su reimplementación. La versión 3.0 apareció en el año 1991, e incluyó una serie de mejoras como una mayor eficiencia en el ejecutor de peticiones. El resto de versiones liberadas a partir de entonces, se centraron en la portabilidad del sistema. El proyecto se dio por finalizado en con la versión 4.2, debido al gran auge que estaba teniendo, lo cual causó la imposibilidad de mantenimiento por parte de los desarrolladores.

En 1994, Andrew Yu y Jolly Chen añadieron un intérprete de SQL a este gestor. Postgres95, como así se llamó fue liberado a Internet como un proyecto libre (OpenSource). Estaba escrito totalmente en C, y la primera versión fue un 25% más pequeña que Postgres, y entre un 30 y un 50% más rápida. A parte de la corrección de algunos bugs, se mejoró el motor interno, se añadió un nuevo programa monitor, y se compiló usando la utilidad GNU Make y el compilador gcc sin necesidad de parchearlo (como había hecho falta en versiones anteriores).

En 1996, los desarrolladores decidieron cambiar el nombre a al DBMS, y lo llamaron PostGreSQL (versión 6.0) para reflejar la relación entre Postgres y las versiones recientes de SQL. Se crearon nuevas mejoras y modificaciones, que repercutieron en un 20-40% más de eficiencia, así como la incorporación del estándar SQL92.

La versión que se ofrece a fechas de este escrito, es la versión 7.2.1. Se puede encontrar más información acerca de las características e historia en [PostGreSQL_Manual].

2.3. Características de PostGreSQL

A continuación se enumeran las principales características de este gestor de bases de datos:

Implementación del estándar SQL92/SQL99.
Soporta distintos tipos de datos: además del soporte para los tipos base, también soporta datos de tipo fecha, monetarios, elementos gráficos, datos sobre redes (MAC, IP …), cadenas de bits, etc. También permite la creación de tipos propios.
Incorpora una estructura de datos array.
Incorpora funciones de diversa índole: manejo de fechas, geométricas, orientadas a operaciones con redes, etc.
Permite la declaración de funciones propias, así como la definición de disparadores.
Soporta el uso de índices, reglas y vistas.
Incluye herencia entre tablas (aunque no entre objetos, ya que no existen), por lo que a este gestor de bases de datos se le incluye entre los gestores objeto-relacionales.
Permite la gestión de diferentes usuarios, como también los permisos asignados a cada uno de ellos.

2.4. ¿Qué es lo que le falta?

PostGreSQL es un magnífico gestor de bases de datos, capaz de competir con muchos gestores comerciales, aunque carezca de alguna característica casi imprescindible. Ésta es, bajo mi punto de vista, un conjunto de herramientas que permitan una fácil gestión de los usuarios y de las bases de datos que contenga el sistema. Por otro lado, la velocidad de respuesta que ofrece este gestor con bases de datos relativamente pequeñas puede parecer un poco deficiente, aunque esta misma velocidad la mantiene al gestionar bases de datos realmente grandes, cosa que resulta loable.

2.5. Opinión Personal

PostGreSQL es un magnífico gestor de bases de datos. Tiene prácticamente todo lo que tienen los gestores comerciales, haciéndo de él una muy buena alternativa GPL. A pesar de ello, el primer encuentro con este gestor es un poco “duro”, ya que la sintaxis de algunos de sus comandos no es nada intuitiva. También resulta engorroso las pequeñas variaciones que presenta este gestor en algunos de los tipos de datos que maneja, siendo el problema más comentado el referente al tipo “serial”.

Una vez nos hayamos hecho con su sintaxis y fijándonos en estos pequeños detalles (que por otro lado están totalmente documentados), PostGreSQL es un gestor magnífico, que posee una gran escalabilidad, haciéndolo idóneo para su uso en sitios web que posean alrededor de 500.000 peticiones por día.

3. MySQL

3.1. ¿Qué es MySQL?

MySQL es un sistema de gestión de bases de datos relacional, licenciado bajo la GPL de la GNU. Su diseño multihilo le permite soportar una gran carga de forma muy eficiente. MySQL fue creada por la empresa sueca MySQL AB, que mantiene el copyright del código fuente del servidor SQL, así como también de la marca.

Aunque MySQL es software libre, MySQL AB distribuye una versión comercial de MySQL, que no se diferencia de la versión libre más que en el soporte técnico que se ofrece, y la posibilidad de integrar este gestor en un software propietario, ya que de no ser así, se vulneraría la licencia GPL.

Este gestor de bases de datos es, probablemente, el gestor más usado en el mundo del software libre, debido a su gran rapidez y facilidad de uso. Esta gran aceptación es debida, en parte, a que existen infinidad de librerías y otras herramientas que permiten su uso a través de gran cantidad de lenguajes de programación, además de su fácil instalación y configuración.

3.2. Historia de MySQL

MySQL surgió como un intento de conectar el gestor mSQL a las tablas propias de MySQL AB, usando sus propias rutinas a bajo nivel. Tras unas primeras pruebas, vieron que mSQL no era lo bastante flexible para lo que necesitaban, por lo que tuvieron que desarrollar nuevas funciones. Esto resultó en una interfaz SQL a su base de datos, con una interfaz totalmente compatible a mSQL.

Se comenta en el manual [MySQL_Manual] que no se sabe con certeza de donde proviene su nombre. Por un lado dicen que sus librerías han llevado el prefijo ‘my’ durante los diez últimos años. Por otro lado, la hija de uno de los desarrolladores se llama My. No saben cuál de estas dos causas (aunque bien podrían tratarse de la misma), han dado lugar al nombre de este conocido gestor de bases de datos.

La versión estable de este gestor a días de hoy es la 3.23.49. Se puede encontrar más información sobre este gestor en el manual [MySQL_Manual].

3.3. Características de MySQL

Las principales características de este gestor de bases de datos son las siguientes:

Aprovecha la potencia de sistemas multiprocesador, gracias a su implementación multihilo.
Soporta gran cantidad de tipos de datos para las columnas.
Dispone de API’s en gran cantidad de lenguajes (C, C++, Java, PHP, etc).
Gran portabilidad entre sistemas.
Soporta hasta 32 índices por tabla.
Gestión de usuarios y passwords, manteniendo un muy buen nivel de seguridad en los datos.

3.4. ¿Qué es lo que le falta?

MySQL surgió cómo una necesidad de un grupo de personas sobre un gestor de bases de datos rápido, por lo que sus desarrolladores fueron implementando únicamente lo que precisaban, intentando hacerlo funcionar de forma óptima. Es por ello que, aunque MySQL se incluye en el grupo de sistemas de bases de datos relacionales, carece de algunas de sus principales características:

Subconsultas: tal vez ésta sea una de las características que más se echan en falta, aunque gran parte de las veces que se necesitan, es posible reescribirlas de manera que no sean necesarias.
SELECT INTO TABLE: Esta característica propia de Oracle, todavía no está implementada.
Triggers y Procedures: Se tiene pensado incluir el uso de procedures almacenados en la base de datos, pero no el de triggers, ya que los triggers reducen de forma significativa el rendimiento de la base de datos, incluso en aquellas consultas que no los activan.
Transacciones: a partir de las últimas versiones ya hay soporte para transacciones, aunque no por defecto (se ha de activar un modo especial).
Integridad referencial: aunque sí que admite la declaración de claves ajenas en la creación tablas, internamente no las trata de forma diferente al resto de campos.

Los desarrolladores comentan en la documentación que todas estas carencias no les resultaban un problema, ya que era lo que ellos necesitaban. De hecho, MySQL fue diseñada con estas características, debido a que lo que buscaban era un gestor de bases de datos con una gran rapidez de respuesta. Pero ha sido con la distribución de MySQL por Internet, cuando más y más gente les están pidiendo estas funcionalidades, por lo que serán incluidas en futuras versiones del gestor.

3.5. Opinión Personal

Tras haber probado la PostGreSQL, y viendo las carencias que poseía MySQL, pensé que no merecería la pena ni tan siquiera probarlo, aunque por otro lado, creía que algo debía tener para que hubiera tanta gente que lo use, cuando está a merced de cada uno elegir la base de datos que quiere usar. La verdad es tras haber hecho unas pocas pruebas, mi impresión sobre este gestor mejoró considerablemente.

Para comenzar, el shell de comandos muestra una interfaz más amena y los comandos para gestionar la base de datos son más intuitivos, siendo muchos de ellos sentencias SQL (hay que decir que no dispone de ayuda en línea sobre las palabras clave de SQL). Por otro lado, la API de PHP para acceder a MySQL era muchísimo más sencilla de usar, teniendo un estilo mucho más natural.

Impresiones en contra, la imposibilidad de usar subconsultas, así como también la definición de vistas, aunque según la documentación oficial, éstas dos características serán incluidas en la versión 4.1 aproximadamente (en las versiones actuales, se incluyen dos comandos, LEFT JOIN y RIGTH JOIN, que son capaces de suplir las subconsultas en gran parte de los casos, obteniendo, por otra parte, una mayor eficiencia).

La verdad es que aunque estas diferencias son agradables, no llegan a tener una importancia suficiente como para cambiar el gestor que habitualmente solemos usar. Este tipo de cambios deberían estar basados en diferencias en el rendimiento que se nos ofrece, que es lo que se tratará en el siguiente apartado.

4. Comparativa

4.1. Introducción

Son muchos los benchmarks que se han publicado sobre estos gestores de bases de datos, aunque muchos de ellos tienen una clara tendencia hacia uno de los dos bandos. Es por esto que hay que saber extraer bien las conclusiones a partir de un benchmark. Por ejemplo, es importante que las comparaciones entre los dos gestores se realicen en igualdad de condiciones, cosa que por otra parte, muchas veces resulta complicado debido a las distintas implementaciones que poseen estos gestores.

Además, resulta muy complicado diseñar un buen benchmark, que tenga en cuenta todas las posibles mejoras de rendimiento que pueda aplicar cada uno de estos gestores. Es lógico pues, que haya algunas pruebas que se le apliquen a un gestor, y que no tenga ningún sentido realizarselas al otro.

A continuación se resumen las conclusiones obtenidas a partir de diversos benchmark’s, intentando hacer un descarte de los que tenían una clara tendencia hacia uno de los bandos.

4.2. Lo mejor de PostGreSQL …

Las características positivas que posee este gestor según las opiniones más comunes en Internet, son:

Posee una gran escalabilidad. Es capaz de ajustarse al número de CPUs y a la cantidad de memoria que posee el sistema de forma óptima, haciéndole capaz de soportar una mayor cantidad de peticiones simultáneas de manera correcta (en algunos benchmarks se dice que ha llegado a soportar el triple de carga de lo que soporta MySQL).
Implementa el uso de rollback’s, subconsultas y transacciones, haciendo su funcionamiento mucho más eficaz, y ofreciendo soluciones en campos en las que MySQL no podría.
Tiene la capacidad de comprobar la integridad referencial, así como también la de almacenar procedimientos en la propia base de datos, equiparándolo con los gestores de bases de datos de alto nivel, como puede ser Oracle.

4.3. … y lo peor

Por contra, los mayores inconvenientes que se pueden encontrar a este gestor son:

Consume gran cantidad de recursos.
Tiene un límite de 8K por fila, aunque se puede aumentar a 32K, con una disminución considerable del rendimiento.
Es de 2 a 3 veces más lento que MySQL.

4.4. Lo mejor de MySQL …

Es evidente que la gran mayoría de gente usa este gestor en Internet, por lo que encontrar opiniones favorables no ha resultado en absoluto complicado:

Sin lugar a duda, lo mejor de MySQL es su velocidad a la hora de realizar las operaciones, lo que le hace uno de los gestores que ofrecen mayor rendimiento.
Su bajo consumo lo hacen apto para ser ejecutado en una máquina con escasos recursos sin ningún problema.
Las utilidades de administración de este gestor son envidiables para muchos de los gestores comerciales existentes, debido a su gran facilidad de configuración e instalación.
Tiene una probabilidad muy reducida de corromper los datos, incluso en los casos en los que los errores no se produzcan en el propio gestor, sino en el sistema en el que está.
El conjunto de aplicaciones Apache-PHP-MySQL es uno de los más utilizados en Internet en servicios de foro (Barrapunto.com) y de buscadores de aplicaciones (Freshmeat.net).

4.5. … y lo peor

Debido a esta mayor aceptación en Internet, gran parte de los inconvenientes se exponen a continuación, han sido extraídos de comparativas con otras bases de datos:

Carece de soporte para transacciones, rollback’s y subconsultas.
El hecho de que no maneje la integridad referencial, hace de este gestor una solución pobre para muchos campos de aplicación, sobre todo para aquellos programadores que provienen de otros gestores que sí que poseen esta característica.
No es viable para su uso con grandes bases de datos, a las que se acceda continuamente, ya que no implementa una buena escalabilidad.

5. Conclusión

Después de haber leído diversos artículos sobre estos gestores de bases de datos, FAQ’s y benchmarks (algunos con un curioso “modus operandi”), la conclusión que se puede sacar es que en realidad no hay que sacar ninguna conclusión sobre el tema. Cada uno de estos gestores es idóneo para ciertos campos, e intentar utilizar el otro acarrearía una pérdida de productividad del programa, como también grandes quebraderos de cabeza.

Ninguno de estos dos gestores son totalmente perfectos, por lo que no hay que obcecarse en la elección única y fanática, como se suele hacer en muchos casos de alguno de ellos. Simplemente se trata de escoger el más conveniente en cada caso. Éstos son los grandes inconvenientes y a la vez las grandes maravillas que conlleva el mundo OpenSource.

Como reflexión final, creo que la pregunta con la que se introducía el escritp podría transformarse en: ¿velocidad o potencia?, siendo su carácter mucho más acertado.

Bibliografía

[MySQL_Manual] Manual de MySQL, https://dev.mysql.com/doc/ .
[PostGreSQL_Manual] Manual de PostGreSQL, https://www.postgresql.org/docs/ .
[Article_MySQL-PostGreSQL] Artículo comparativo, http://www.phpbuilder.com/columns/tim20000705.php3?page=1 .

About me

Sun, 30 Oct 2016 22:17:20 +0100

Software developer, expert in technologies like JVM languages, Node.js, Golang & frontend, among others, with a wide range expertise in several technology stacks like MEAN (MongoDB, ExpressJS, Angular, Node.JS) or Java/JEE (SCJP5 Certified).

Passionate about his job, loves non-stop learning, blogging and facing new challenges to improve in what he enjoys most: creating software. And if it can improve someone else’s life, even better.

TDD and agile practitioner, has developed several OpenSource projects pet projects as well as for final clients, always trying to apply latest technologies to improve final user experience. Take a look in one of these sites.

Github: https://github.com/dpecos
BitBucket: https://bitbucket.org/dpecos

Freelance consultant. More than 10 years developing web based (enterprise and public) solutions.

Currently based in Amsterdam area, Netherlands, but accepting relocations or remote positions.

Active member of several local user groups (Javascript, Golang, Frontenders, Makers). Speaker and trainer in different subjects:

Functional Programming
Javascript
JEE
Web Security

You can contact him commenting in this page or via one of the following social network profiles:

LinkedIn: https://www.linkedin.com/in/danielpecos
Github: https://github.com/dpecos
Twitter: https://twitter.com/danielpecos
Google+: https://plus.google.com/u/0/+DanielPecosMartínez
Facebook: https://www.facebook.com/daniel.pecos

Un monstruo viene a verme

Fri, 28 Oct 2016 05:43:14 +0100

Es media noche, Conor apenas se despierta luego de tener la misma pesadilla que lo agobia todos los días. Pero, en esta instancia los hechos han sido diferentes, ya que esta vez un monstruo lo espera en el jardín de su hogar, pues el árbol antiguo y robusto que antes solía observar desde la ventana de la cocina, ahora dispone de brazos, piernas y un rostro completamente aterrador.

Sin embargo, el monstruo no pretende asustarlo, tan solo está buscando una cosa: la verdad, algo que Conor no desea contar bajo ninguna circunstancia. Este personaje tiene trece años de edad, y está atravesando una pésima situación, dado a que su madre se encuentra enferma de cáncer, además sufre de acoso escolar y su padre no vive con él, pues vive en América tras conocer a otra mujer.

Pero lo único que el adolescente quiere es que la visita del monstruo suponga el fin de las pesadillas que lo asedian durante todas las noches. Así se produce el desenlace de Un monstruo viene a verme, un libro que hace referencia a las dificultades por la que atravesamos los seres humanos para aceptar una valiosa pérdida y lidiar con los lazos vulnerables que nos mantienen sujetos a la vida.

La aleación perfecta entra la realidad y la ficción

Al comienzo de la historia, da la impresión de que nos estamos adentrando a un cuento de terror, pero al sumergirte más en la lectura de Un monstruo viene a verme, notarás que realmente se trata de una trama muy profunda, que conjuga a la perfección lo irreal con la más severa realidad.

Empleando un vocabulario fácil de comprender, que está al alcance de todo público, el escritor Patrick Ness nos invita tácitamente a reflexionar y a pensar acerca de la realidad antes de pasar cada página. El estilo en que se relata la historia es sumamente impecable y logra que la lectura sea diferible y fácil, por lo que no se torna pesada en ningún momento.

En síntesis, Un monstruo viene a verme despertará en ti un cúmulo de emociones, ya que te hará reír, reflexionar y hasta llorar, pero lo más importante es que podrás disfrutar de los escenarios que se crean en esta historia fantástica.

Merecedor de números premios

Este libro ha sido publicado en diecisiete países y ha sido galardonado con el Premio Nacional Galaxy, gracias a la votación de un grupo de libreros especialistas en el área, también ostenta el Premio The Red House, donde el laurel depende de la decisión de un grupo de niños.

Además, Un monstruo viene a verme es el primer libro en ganar al unísono, dos de los más famosos premios del Reino Unido, que son: la Medalla Kate Greenaway, en virtud de las asombrosas ilustraciones de Jim Kay, y la Medalla Carnegie al mérito literario del escritor, Patrick Ness, aunque la idea de la historia se le atribuye a Siobhán Dowd, la autora de varios libros juveniles, que no pudo culminar el material bibliográfico tras fallecer en 2007.

Inferno

Tue, 25 Oct 2016 05:38:00 +0100

El profesor Robert Langdon se despierta a mitad de la noche en un hospital, con una herida en la cabeza ocasionada por una bala, sin embargo, el docente de simbología no tenía idea de cómo sucedieron los hechos, ya que no recuerda nada de los últimos dos días, tampoco cómo había llegado al centro médico, ni de la procedencia de una objeto macabro que hallaron en el bolsillo de su chaqueta.

Una historia llena de acertijos

Tras lo ocurrido, el mundo de Langdon pronto se transforma en un caos, por lo que se ve obligado a huir por las calles de Florencia, ya que en el hospital donde se encontraba internado una joven buscó asesinarlo. Sin embargo, una inteligente doctora llamada Sienna Brooks, le salva la vida ayudándolo a salir del centro hospitalario. En su huida y con la compañía de la doctora, el profesor irá a reunir información que lo conducirán a nuevos desafíos y retos, que le permitirán descifrar códigos y jeroglíficos, que a medida en que se topa con estos acertijos la trama se va tornando más siniestra e inquietante.

Al tiempo descubre, que no solamente la joven del hospital quería quitarle la vida, sino también unos “hombres de negro”, que estaban equipados con tecnología de punta. Langdon y Sienna recorren escenarios conocidos en Florencia como el Palacio Vecchio y los jardines Boboli, entre otros lugares.

En su camino por las calles, el profesor se encuentra con símbolos, llamativos cuadros, estatuas y sitios con pasadizos secretos por toda Florencia, una parte de Venecia y en Estambul, por lo que no tardará en percatarse de que está ante una conjunto de códigos diseñados por un científico obsesionado con el fin del mundo, que solo es comparable a su atracción que tiene por una de las obras maestras de más reconocimiento en el mundo: Inferno de Dante Aligheri.

Un libro complicado pero logra enganchar

El Infierno de Dan Brown es una lectura complicadamente divertida, que es capaz de cautivar al lector a través de la belleza del arte, la literatura italiana y la historia, mientras que a su vez plantea conjeturas acerca del rol que tendrá la ciencia en los tiempos venideros. Por otro lado, la trama mantiene una coherencia y lógica muy interesante.

Además, nos ofrece una percepción muy llamativa, a medio camino, entre los hechos y las suposiciones sobre la vida y obra de Dante. En la historia se van desnudando paulatinamente la influencia que tuvo el escritor en el concepto cristiano del infierno y cómo su obra influyó en la visión religiosa de otros artistas.

El infierno de Dan Brown y su gran lanzamiento

El Infierno de Dan Brown fue traducido en alemán. Turco, francés, catalán, español, neerlandés, italiano, portugués, entre otras lenguas, todo esto con el propósito de ser lanzado mundialmente de manera simultánea en estos países.

Pero, aunque este libro, tiene sus puntos cuestionables desde la perspectiva de la calidad narrativa, aun así, logra enganchar al lector e introducirlo en un universo de maquinaciones y conspiraciones del que difícilmente se puede huir una vez que se entra en él.

Me cuesta llegar a fin de mes, ¿cómo ahorro?

Thu, 20 Oct 2016 06:09:27 +0100

Ya hemos comentado que el ahorro es la base de la inversión, pero ¿cómo conseguir ahorrar si a duras penas llego a fin de mes? Aunque sin fácil solución, te voy a comentar algunos trucos o consejos que he utilizado en alguna ocasión.

Primero y posiblemente el más importante: reduce gastos fijos. ¿Necesitas todo lo que tienes contratado? Puedes empezar por reducir la cobertura del seguro del coche, la velocidad del internet contratado, la tarifa del móvil, incluso servicios absurdos, como por ejemplo el servicio de identificación de llamadas de la línea fija (sí, no es broma, 1€/mes)
Renegociar condiciones hipotecarias: puede que no sea fácil o incluso una opción en ese determinado momento, pero estad siempre pendientes de las condiciones hipotecarias que ofrece el mercado. Es posible que un cambio de banco o una renegociación de condiciones con el actual, nos ayude a aumentar nuestro líquido disponible. Consejo: tratad de no alargar los plazos de amortización, eso se termina traduciendo en mayor pago de intereses al final del préstamo o hipoteca.
Austeridad: si tenemos problemas para llegar a fin de mes, reduce gastos puntuales que no sean directamente esenciales: eventos sociales (cines, cenas, cubatas, …), llévate comida de casa en vez de comer de restaurante o trata de reducir el uso del coche (haz un uso compartido o incluso utiliza la bicicleta si es posible)
Busca liquidez a coste 0: por ejemplo, un truco que he usado en alguna ocasión para no tirar de crédito de tarjeta para obtener liquidez consiste en hacer compras de valor importante de familiares que vayan a comprar por voluntad propia (no es cuestión de obligarles a gastarse el dinero), pagarlas con mi tarjeta en modo aplazado a final de mes (que en mi caso, y seguro que en el de muchos más, no tiene coste alguno) y que éstos nos den el dinero en metálico. Con esto conseguimos algo de liquidez extra. Aunque no hay que pasarse con ésto, ¡a final de mes llegará puntualmente el acumulado total de la tarjeta!
Buscar ingresos extras: buscar tareas en webs de freelance que nos permitan obtener un dinero extra. Por lo normal, requerirán que les dediquemos un determinado esfuerzo / tiempo (estamos vendiendo nuestro tiempo, que es el único bien del que disponemos y que siempre va en decremento), por lo que no es el ideal, pero siempre será mejor que aumentar nuestro endeudamiento. Lo ideal sería conseguir una fuente de ingresos pasivos, pero eso es algo que requiere algún tiempo.

Para terminar, mi última recomendación es que trates por todo lo posible de pedir préstamos o aplazar pagos de tarjetas. Todo esto tiene un coste asociado, por lo que terminarás pagando más de lo que inicialmente precisabas, por lo que si no es del todo imprescindible (y en tal caso, meditar largo y tendido si realmente nos va a hacer algún bien) evita el contratar este tipo de servicios.

El Juego de Ender

Thu, 20 Oct 2016 06:00:02 +0100

Una especie extraterrestre con apariencia de insectos ataca la Tierra. Estos seres son capaces de comunicarse telepáticamente y se catalogan como una especie superior a los humanos, por lo que se proponen destruir a cada persona que habite en el mundo.

Sin embargo, la humanidad tratará de evitar su exterminio, así que para vencer a los insectores (nombre de los extraterrestres) necesitan de un genio militar capaz de contrarrestar esta amenaza, por lo que permiten el nacimiento de Ender, el tercer primogénito de una pareja en un planeta donde se ha reducido el número de descendientes a dos personas.

Ender nació para recibir entrenamiento especial en una estación, luego de que su hermana mayor y Peter (su hermano) hayan sido considerados como no aptos para la misión. Y bajo la estricta supervisión de la Flota Internacional, el respetado Coronel Hyrum Graff se hace cargo de comandar el entrenamiento, donde estos jóvenes, quienes se distribuyen en grupos, combaten entre sí, utilizando armas que paralizan sus armaduras.

Los simuladores en El Juego de Ender

En consecuencia, Ender deberá aprender cada uno de las técnicas alusivas a la guerra a través de videojuegos y en los difíciles ensayos de batallas que realiza junto a sus compañeros de entrenamiento. Por consiguiente, a la habilidad de cómo se narran las emociones en esta novela, también se le añade un elemento muy llamativo, que es el empleo de las simulaciones y juegos de fantasía en la preparación militar, psicológica y estratégica del protagonista.

Ahora bien, Ender logra desarrollar habilidades únicas y su potencial para luchar es más avanzada que la de los demás, así que rápidamente sube de rango en la estación y termina convirtiéndose en un líder indiscutible, es decir, en el guerrero más apto para dar órdenes a las flotas terrestres contras los insectores. Sin embargo, al llegar a la Escuela de Alto Mando, el prodigioso guerrero se percata que la guerra contra la especie extraterrestre es mucho más difícil de lo que se había imaginado.

El futuro del mundo depende de Ender

De esta forma, comienza la acción en El Juego de Ender, donde se pretende salvar a la humanidad de un Apocalipsis y un futuro devastador. Así que el destino de la humanidad está en mano del nuevo y legendario Mazer, que es nada menos que Ender Wiggin, cuya personalidad es bastante tímida pero posee un talento innato y peligroso para los enfrentamientos bélicos.

Una lectura épica

El Juego de Ender está perfectamente relatado, gracias a que logra recrearte imágenes en tu mente acerca de las batallas, de manera que te las imaginas totalmente, lo que resulta muy divertido a la hora de leer un libro.

Por otra parte, el autor Orson Scott Card, describe de manera excepcional los diferentes estados de ánimo del protagonista, que frecuentemente tiende a reflexionar acerca del sentido del juego, incluyendo a sus jóvenes compañeros, colegas, superiores y sus subordinados, así como también a su familia.

Si obtienes El Juego de Ender te darás un gran banquete y tendrás la oportunidad de disfrutar de un bestseller, que fue galardonado en los premios más afamados de la ciencia ficción: el Premio Nébula como la mejor novela en 1985 y un año después el Premio Hugo.

El Marciano

Mon, 17 Oct 2016 06:00:05 +0100

El astronauta de la NASA, ingeniero mecánico y botánico, Mark Watney, es integrante de una tripulación de seis personas de la misión Ares 3, que está destinada en ser la primera en aterrizar y realizar estudios en Marte. Pero una tormenta de arena con vientos que supera a gran escala los pronósticos de la NASA, obligó al equipo espacial a abandonar el Hab (habitáculo donde iban a residir) y a despegar hacia la Hermes (la nave espacial en la que llegaron en órbita).

Durante el proceso de evacuación, el potente viento marciano desprendió la antena parabólica de radio del Hab, impactando en la integridad física de Mark, ocasionándole una herida en la zona del abdomen y al mismo tiempo fue arrastrado por el viento, lo que generó que se extraviara en Marte.

Ante este incidente, Lewis, quien es la capitana de la misión, luego de varios intentos de rescatar a Mark toma la decisión de abandonar Marte, pensando que el astronauta había fallecido. Pero para fortuna de Mark, el hierro de la antena y la sangre de la herida, cubren la lesión y sellan el traje, haciendo que el astronauta se mantenga con vida.

Sólo, en Marte

Así es cómo empieza la aventura de Mark y se genera el desenlace en El Marciano, ya que el astronauta se encuentra solo en este planeta, con alimento para un año -debido a que se queda con el suministro para seis personas- y sin probabilidad de hacer contacto con el planeta Tierra sin la antena de radio.

Analizando su situación, se percata que su única oportunidad de mantenerse con vida por más tiempo es sobrevivir durante cuatro años, el tiempo que tardará en regresar la misión Ares 4.

En la Tierra los científicos de la NASA se dan cuenta que Mark continúa vivo, gracias a los satélites que orbitan el planeta Marte, por lo que empiezan a trabajar para intentar auxiliarlo con las pocas opciones que tienen.

Su lucha por sobrevivir

Mark sigue luchando para seguir con vida, así que contando con su ingenio, sus habilidades y sus conocimientos de botánica, logra encarar obstáculos que parecen insuperables. Además, su sentido del humor se convierte en el motor que le provee fuerza para continuar luchando y aferrándose a la idea de seguir viviendo, por lo que ejecutará un plan maestro para ponerse en contacto con la NASA.

Una gran experiencia literaria

Con un final espectacular, El Marciano es una novela de ciencia ficción escrita por Andy Weir que se ha convertido en un bestseller online, obteniendo una gran cantidad de ventas en plataformas como Amazon.

La historia forjada en este libro posee un delirio fantástico y una mecánica de suspenso que sorprende al lector, haciendo que éste se adentre en el cosmos y el instinto humano de luchar por la supervivencia. En síntesis, El Marciano hará que tengas una experiencia literaria irrepetible.

Esta novela ha cautivado a insignes personajes como al astronauta y comandante de la Estación Espacial Internacional, Chris Hadfield, al autor de Ready Player One, Ernest Cline, al famoso escritor estadounidense, Steve Berry, entre otros intelectuales, fanáticos y reconocidos artífices de obras literarias.

El portal de noticias The Wall Street Journal, ha catalogado a El Marciano como: “La mejor novela de ciencia ficción en años”. ¿Qué esperas? ¡Anímate! Una vez que empieces no pararás de leerla.

Ready Player One

Thu, 13 Oct 2016 20:49:22 +0100

En el año 2044, el mundo es cada vez más un lugar sombrío, con terribles carencias para la población, razón por la cual, muchas personas escapan de esta realidad participando en el videojuego “Oasis”, entre ellas nuestro protagonista Wade Watts, un adolescente solitario, común y un tanto deprimido que sabe lo afortunado que es por tener un techo, comida suficiente y unas condiciones de vida mucho mejores que la mayoría.

En “Oasis” los jugadores forman comunidades virtuales, y pueden jugar en diversos universos de ciencia ficción (Star trek, Dune, Star Wars, Firefly); sin embargo, Wade está atascado en los niveles más básicos del juego pues no tiene suficiente puntos de experiencia ni dinero virtual para viajar a esos mundos.

El creador del juego, James Hallyday murió muy recientemente, y no tuvo hijos, por lo que decidió dejar su fortuna y el control del juego a quien logre encontrar un easter egg (un mensaje oculto) dentro del juego; ya van 5 años de jugadores buscando el mensaje sin éxito alguno, y la única pista que tienen es que se relaciona a los años 80s, (pues Hallyday estaba obsesionado con esa época).

Es aquí cuando la vida Wade da un vuelco rotundo, al lograr descubrir una pista y avanzar en la búsqueda, ubicándose (con su pseudónimo en el juego llamado Parzival) en solitario en el ranking; esto le da prestigio en el importante mundo de Oasis, pero a la vez cambiará su vida y causará que se vea involucrado en retos y búsquedas que no pertenecen solo al mundo virtual.

Un libro amado por los gamers

Ready Player One se ha convertido en un libro de culto, es muy apreciado por retratar con autenticidad el espíritu de los gamers y su sentido de comunidad; y a la vez por incorporar elementos atrayentes para los amantes de la ciencia ficción y de lo relacionado a la cultura de los años 80s (música, videojuegos, películas, tv, juegos, cultura pop).

En la historia los jugadores de Oasis usan un visor y guantes hápticos (para realidad virtual) para adentrarse en un mundo de gran realismo, donde, a su vez, es posible visitar otros mundos donde pueden o no, usar magia o tecnología; incluso es posible asistir a la Escuela en este mundo virtual.

Próxima adaptación al cine

Además de su atrayente trama, otra razón para leer este libro muy pronto, es que actualmente se está filmando su adaptación cinematográfica, dirigida por el reconocido directo Steven Spielberg. El estreno está planificado para Marzo del 2018 y en el guion está participando el autor.

Entretenimiento para todos

En definitiva, Ready Player One es un libro que logra atrapar a todo tipo de lectores, pues la suma de sus componentes: una buena historia con argumentos sólidos, personajes con los cuales el lector se puede sentir identificado por ser comunes y corrientes, y una búsqueda constante para alcanzar un objetivo tangible; garantizan una lectura divertida y emocionante, que ha atrapado y cautivado a millones de personas alrededor del mundo.

Harry Potter y el Legado Maldito

Thu, 13 Oct 2016 20:22:29 +0100

La historia del niño que vivió es conocida mundialmente, es referencia cultural y conserva vigencia entre las generaciones que crecieron viviendo el fenómeno de los libros y películas de Harry Potter, y aún logra atraer a muchos nuevos lectores y espectadores, curiosos y ávidos de sumarse a este universo.

Es por eso, que el mundo no puedo recibir el libro “Harry Potter y el Legado Maldito”, con más que inmensas expectativas, luego de casi diez años del final de la saga.

En esta historia, J.K.Rowling nos narra, en forma de obra (el libro corresponde al texto de la obra de teatro que actualmente se presenta en Londres, con el mismo nombre) una historia situada 19 años después de que el trío dorado (Harry Potter, Hermione Granger y Ron Weasley) resulte vencedor contra Voldemort en la Batalla de Hogwarts.

Es el presente y Harry, casado con Ginny Weasley tiene tres hijos, James, Albus y Lily. El hijo del medio, Albus Severus, está por empezar su primer año en Hogwarts junto a Rose Weasley (hija de Hermione y Ron), y no está muy seguro de cómo vivir bajo la sombra de todos los logros, fama y errores de su padre. Lo más peculiar es que Albus, entabla una amistad desde el principio con alguien inesperado, Scorpius Malfoy, el único hijo del conocido Draco Malfoy (enemigo de Harry y su grupo en el tiempo de Hogwarts).

Por su parte, Harry Potter, héroe del mundo mágico, es Jefe del Departamento de Seguridad Mágica, y sumado a los retos que presenta este trabajo, debe lidiar con las diferencias que tiene con su hijo Albus Severus; y con hechos del pasado que insisten en seguirlo y generar conflictos que pueden tener graves consecuencias para todo el mundo mágico, incluyendo viajes en el tiempo, que como sabemos, pueden alterar gravemente lo ocurrido en pasado, presente y futuro, permitiendo la reaparición de enemigos derrotados, como Lord Voldemort.

Una historia que nunca muere

En palabras de su autora “Ninguna historia vive al menos que alguien quiera escucharla” y en definitiva, todo el universo de Harry Potter, sus incontables aventuras, sus personajes, aún tienen vigencia y causan interés, es por eso que el libro Harry Potter y el Legado Maldito ha sido esperado con tantas ansias, no solo por los seguidores y fanáticos; sino también por el mundo literario, curioso por saber que le ha deparado el futuro a la historia del mundo mágico y que novedades ha incorporado su escritora.

Algunos fanáticos de la serie se han mostrado un poco preocupados, pues no están seguros de que Harry Potter y el Legado Maldito esté a la altura de la saga original, y sabemos que difícilmente logre complacer a todos los lectores, pues parte de la magia es lo que cada quien imagino que ocurría con los personajes luego de Harry Potter y las Reliquias de la Muerte; sin embargo, esa sensación cálida de volver a un viejo amigo, al empezar las páginas del que sería el octavo libro en la serie, de seguro estará presente para todos.

Diversificar inversiones para aumentar nuestra tranquilidad

Tue, 11 Oct 2016 05:59:58 +0100

Antes de asumir el riesgo que supone la inversión en Bolsa, quise asegurarme de que era el modo que quería utilizar para sacar rendimientos a mis ahorros. Todo el mundo sabe que invertir en bolsa es algo arriesgado y en aquel momento prefería optar a un rendimiento menor a cambio de una mayor seguridad de retorno de mi dinero.

¡Manos a la obra! Acto seguido empecé a bucear por las páginas de inversión de las entidades bancarias con las que trabajo e ir extrayendo una lista de productos tipos a fin de poder investigar sobre cada uno de ellos y las condiciones que les aplican. Tras unas horas de investigación conseguí la siguiente lista de productos:

Depósitos
Fondos de inversión
Seguros de ahorro
Planes de pensiones
Bolsa
Y alguno más… (Tranquilos, en posteriores artículos entraré en detalle con cada uno de ellos)

¿Por cuál decidirme? Cada uno tenía sus ventajas e inconvenientes. Tras mucho leer en foros, llegué a una línea argumental bastante común: diversificar las inversiones, no sólo decidiendo en qué empresas invertir, sino en qué productos utilizar. De esta forma, repartiendo tus ahorros en distintos productos, consigues una mayor seguridad financiera. En general, no resulta conveniente poner todos los huevos en la misma cesta.

El problema que le vi a este enfoque, es que, a parte de conservador, requería un capital considerable, puesto que la diversificación lo repartiría en montoncitos de menor tamaño. En mi caso era poco viable debido a los ahorros de partida, por lo que a pesar del consejo, decidí centrarme en la inversión en bolsa.

Por último y antes de terminar, quería comentaros un par de opciones que me resultaron de especial interés (por su novedad) y que recuperé a través de contactos, foros y blogs especializados en inversión:

Inversión inmobiliaria: y no hablo de comprar un piso asumiendo una hipoteca (y sus intereses) con el fin de venderlo en un futuro, sino de compras en comunidad (crowdfunding), por decirlo de algún modo, que permiten destinar parte de nuestro dinero a la compra de una vivienda real, rehabilitarla, alquilarla durante un determinado tiempo, repartiéndose el importe del alquiler entre los propietarios (a modo de dividendo) para finalmente vender la vivienda y repartir beneficios. Personalmente, conocía el crowdfunding, pero no lo había visto todavía aplicado a la compra / venta inmobiliaria. Realmente me pareció muy interesante, y puesto que no hay un mínimo para participar, resulta una opción a considerar. Para más detalles, consultad la web de Housers (gracias a mi amigo Fidel Añó por comentarme este tipo de inversiones!)

Inversión en negocios en fases iniciales (a.k.a startups): sin duda es la opción que más retorno puede producir, pero también la más arriesgada. Por Silicon Valley se dice que más del 90% de las startups resultan fallidas. Lo suyo es, una vez más, diversificar en distintas startups y buscar ese 10% que cubra al resto de inversiones fallidas y retorne un beneficio. Y sobre todo, tratar de encontrar aquella que se convierta en unicornio (se valore en más de 1.000 millones de $), lo cual no es tarea fácil. Aún así, si dispones de una cantidad importante de ahorros, y dado el efecto social que genera este tipo de inversión (creación de autoempleo, fomento del emprendedurismo, buena publicidad al inversor, etc) resulta una opción a tener en cuenta.

Sin duda el momento actual de crisis por el que estamos pasando, aumenta la creatividad de las personas, y no sería nada raro ver nacer nuevos tipos de productos o proyectos inversión como el de Housers.

Permanezcamos atentos, lo bueno puede estar por venir.

Padre Rico, Padre Pobre

Thu, 06 Oct 2016 06:00:09 +0100

Intentar abordar desde el desconocimiento una técnica de inversión para conseguir revalorizar tus ahorros, está desde mi humilde punto de vista, destinado al fracaso. ¿Por qué tropezar con piedras con los que otros ya lo han hecho y además han explicado el camino que llevaban y sus consecuencias? (Una de las referencias que personalmente suelo utilizar para conseguir consejo es precisamente mi padre, al igual que el autor de este libro, y supongo que muchos otros más).

Es por ello que ya desde un primer momento decidí que parte de los ahorros tenía que destinarlos al aprendizaje sobre inversión, empezando por libros introductorios a este mundo. Pero no creas que resulta fácil. Existe mucha literatura que trata el tema de la inversión, y mucha de ella, de baja calidad o refritos de otros libros.

Por lo que tras leer algunos comentarios, decidí comenzar con éste:

Padre Rico, Padre Pobre

En este libro el autor narra cómo desde muy joven se introdujo en el mundo de la inversión, y las disyuntivas que se le planteaban entre su padre biológico (Padre Pobre) y el padre de su mejor amigo (Padre Rico). Padre Rico era un empresario de su pueblo natal que le enseñaría a comprender los flujos del dinero y la forma de pensar de las personas acerca del dinero y el trabajo.

Es un libro realmente ameno y fácil de leer, y aunque está escrito para un entorno legal americano (hay algunos puntos legales que en España no son trasladables), me resultó clarificador y sobre todo motivante.

Mi valoración personal (escala de 0 – Nada recomendable a 5 – ¿Cómo es posible que no lo tengas?): 4

La base de la inversión: el Ahorro

Mon, 03 Oct 2016 08:09:37 +0100

Posiblemente si algo tuviera que ser la piedra angular de la inversión, apostaría a que lo es el ahorro.

Y es que parece lógico que para poder invertir en cualquier tipo de producto financiero, es necesario disponer de un mínimo de líquido disponible. Parece una obviedad, pero la constancia en el ahorro, determinará nuestra disponibilidad de capital para la inversión.

Pienso que ahorro e inversión son dos caras de una misma moneda: el ahorro es la herramienta que permite a la inversión hacer que éstos crezcan.

Por ello es importante preparar un análisis del flujo de efectivo mensual. Un simple ejercicio de introspectiva financiera. No es más que una hoja de cálculo donde se indiquen todos los ingresos y gastos previstos mes a mes. No es necesario ser super detallado, pero sí no olvidar ninguno de los gastos que de forma normal ocurren en cada periodo del año (primas de seguros, gastos de comunidad, vacaciones, etc). Es muy importante ser honesto con uno mismo, así como también incluir una partida para gastos imprevistos.

Con este análisis veremos cuál es nuestro disponible estimado mes a mes, y así poder determinar qué montante destinamos a ahorro. Personalmente he decidido ahorrar 500€ todos los meses. Es una cantidad que está ligeramente por encima de lo que me resulta cómodo, pero creo que de esta forma podré acercarme más rápidamente a la libertad financiera.

Todavía es pronto, pero voy intuyendo que poner todos los huevos en la misma cesta no es una opción demasiado acertada, por lo que tendré que ir planteándome cómo repartir estos ahorros mensuales en distintos tipos de inversión, no sólo bolsa.

Diversificar al fin y al cabo, posiblemente otras de las herramientas base para conseguir mayor seguridad.

No quiero perder el foco: no quiero dejar totalmente al azar el futuro de mis ahorros, si no que quiero minimizar riesgos aunque ello implique un rendimiento menor.

Aunque tampoco quiero engañarme: algún riesgo hay que asumir, aunque éste sea menor.

¿Es la bolsa la inversión que quiero para mis ahorros?

Thu, 29 Sep 2016 05:51:17 +0100

Sede de la bolsa de mercados y valores de madrid

Permíteme que te explique cómo decidí que la inversión en bolsa era el camino que quería seguir para rentabilizar mis modestas inversiones.

Todo empezó por una (creo que sensata) preocupación por cómo llegaría al momento de mi jubilación. La primera preocupación, y aunque parece remota, era siquiera si iba a disponer de una jubilación y la segunda, si la cantidad a percibir cubriría lo que a mi me gustaría. Al fin y al cabo son los últimos años de tu vida disponibles para disfrutar, tras más de 40 años de trabajo.

Esto me llevó por el camino más lógico: buscar planes de jubilación privados. Todo suena bien en un primer momento: ahorras la cantidad que te parezca oportuna (incluso algunos de ellos no te imponen una periodicidad) y además reduces tu base imponible, ahorrándote impuestos cada año. ¡Y encima el dinero genera intereses!

Pero (tenía que haberlo) pierdes la disponibilidad de esos ahorros hasta el momento de la jubilación. Es verdad, hay condiciones de rescate bajo las cuales es posible recuperar tus ahorros de forma anticipada, pero en cualquier caso, si estás en esas condiciones, estás realmente jodido y el disponer o no de tus ahorros de toda la vida no es el mayor de tus problemas llegados a esa situación.

Continué investigando y lo siguiente en que me fijé fueron los depósitos a renta fija y los fondos de inversión (en renta fija), cualquier cosa que sonara a renta variable me daba realmente pánico ¿quién en su sano juicio quiere jugarse su esfuerzo por un posible beneficio? Estos tipos de productos en general dan un buen nivel de seguridad aunque a unos intereses modestos. Aún así, frente a las ventajas fiscales que ofrecen los planes de jubilación, se me quedaban algo cortos.

Así pues, parece que la renta variable es la única opción restante y no demasiado descabellada como puede ser la inversión en futuros, derivados o CFDs. Pero mi conocimiento de este tipo de productos es muy superficial, necesitaría tiempo para conocer el mercado y las características de éstos, antes de ponerme a invertir en serio en cualquiera de estas opciones.

Llegados a este punto decidí meter la cabeza en la operativa de bolsa con un capital mínimo, así que contraté el broker de ING, invertí 1.000€ en una ETF que replica el IBEX (ahora mismo, se encuentra en valores bajos teniendo en cuenta su histórico y es de esperar que a medio / largo recupere el valor de 10.000 o más) y que además reparte dividendos y me daría unos meses a mi mismo para formarme y poder tomar decisiones con una mejor base.

Y en este punto me encuentro. En futuros posts explicaré más en detalle los distintos productos de los que he estado hablando e iré revisando los distintos libros que vaya leyendo y compartiendo mi opinión sobre ellos con todos vosotros.

¿Interesado en invertir y no sabes por dónde empezar?

Wed, 28 Sep 2016 03:55:09 +0100

No te sientas solo, es lo más normal.

Y lo digo porque a mi me pasa exactamente lo mismo: es un mundo lleno de _jargon _y donde cometer un error sale caro, pero por contra, el potencial beneficio es muy interesante.

¿Y por qué si no tengo ni idea de en lo que me estoy metiendo, sigo adelante?

Primero: quiero ahorrar y que mis ahorros crezcan lo máximo posible, como le gustaría a cualquier hijo de vecino.

Segundo: aunque en este punto 0, optar por la libertad financiera queda lejos, el objetivo está claro y el camino todo un reto.

Y por último: porque es emocionante.

En este blog trataré de ser lo más trasparente posible sobre los pasos y decisiones que voy tomando, así como sus resultados y conclusiones. Además compartiré todos lo utilizaré como libreta de apuntes, con el fin de allanar el camino al resto de novatos que se quieran internar en este mundo de la inversión.

Bienvenido!

PAPIs.io Connect 2016 – Valencia

Tue, 15 Mar 2016 20:35:00 +0100

I just got home after enjoying a couple of days in the PAPIs.io Connect conferences in Valencia. And they’ve been great!

There have been sessions about Machine Learning, Deep Learning, APIs, AI, BigData and many more. Oh, and there have been drones too.

To summarize, the ecosystem surrounding BigData and AI technologies is amazing and currently is really on fire. In my humble opinion, I think this quote from Ramón López de Mántaras’s keynote “Past, Present and Future of AI: A fascinating journey” describes the energy and enthusiasm that people working in AI and BigData transmit when they talk about the matter:

The goal of human-level intelligence remains elusive but has inspired and still inspires our work on AI

Speakers from many different companies, like Amazon, ING, BigML, Telefonica R&D, So1, Ŷhat, just to name a few, have been talking about their experience in solving many different types of problems using Machine Learning technologies and what the main benefits and caveats have they found during the process.

Just to provide an idea of the huge amount of effort and solutions around BigData and what the ecosystem looks like nowadays, nothing better than this image:

Great speakers, really cool topics for the talks and really nice venue.

What else could you ask for? Oh yeah, Valencia’s Fallas and great food!

In the following link you can have a look into the activity that has happened in Twitter #papisconnect hashtag during the event:

https://twitter.com/hashtag/papisconnect

EDIT (2016/03/16): Completely forgot to mention the Startups Battle. It was really cool to see how a AI (preseries) drives an interview in order to rank an startup, using BigML technology and Amazon Echo. My only concern was that it never asked a single question about any project at all, just questions about the team experience and seed rounds. Is that the only thing that matters to get your project fund? Don’t think so.

Surprises with Java packages

Wed, 23 Dec 2015 16:30:00 +0100

Packages in Java is a quite simple and straightforward concept of the language. It’s there from the beginning and it’s commonly used by every Java programmer. In a few words, these are the rules you have to follow to create a class inside a package (spoiler: which are not completely true, as we’ll see later):

Package statement must be the first one specified in a java class file
A package namespace must match the physical path of the file, i.e a class defined with a package a.b.c must be placed in a path a/b/c/

Easy right? Let’s check…

Turns out that the second rule is not mandatory but a recommendation (a good one, BTW), but Eclipse IDE enforces it to the point that if you don’t follow it, it throws a compilation error. Let’s open the following class in Eclipse:

package a.b.c;

public class HelloWorld {
 public static void main(String[] args) {
   System.out.println("Hello world!");
 }
}

And you’ll get the following error:

But as I said, it’s not a restriction of the language but from the IDE itself:

In fact, turns out that manually compiling this class works perfectly fine (also tried maven and worked flawesly):

$ javac src/HelloWorld.java -d bin

$ java -cp bin a.b.c.HelloWorld
Hello world!

$ tree bin/
bin/
└── a
    └── b
        └── c
            └── HelloWorld.class

Corollary: if you’re a programmer, don’t trust even the most basic and accepted statement you could think of. Even if you’re absolutely right at this very moment, it will eventually be modified and surprise you.

Codemotion 2015

Sun, 29 Nov 2015 22:00:00 +0100

Day after Codemotion 2015, this is my overall opinion of the event: meh. Don’t get me wrong, technical sessions have been quite interesting, full of really nice people and organization must have worked really to get the event running. But, in my opinion, this event is dying of success. Way too many assistants, making really hard to walk from one session to another (even having 15 min between them), or having to arrive 30 min before start if you’re intention was to have a nice place to plug your laptop and be able to see the presentation.

Now, speaking about content, it’s really nice to have so much diversity to choose from in every time slot (although sometimes you were force to discard really nice sessions). Personally, I chose to assist to an JVM / Scala track that covered approximately the whole time slots of the first day (and part of the second) without significant overlaps. BTW, really interesting stuff is happening around the JVM, nothing to envy to the Node.js community.

But I also wanted to have a look into different technologies which were newer to me, such as Docker or Big Data. And it’s impressive how much has the technology evolved and what amazing things are people achieving in these fields. Currently, recorded sessions are ~~not yet published~~ already published!, but I’m pretty sure it will be worth taking a look into what I missed.

But as always, the best thing of these events is the people you meet, old and new acquaintances. And, of course, nothing as a good as an old arcade machine and a StreetFighter match in the chill out area to relax and have some fun 😉

Coursera: Principles of Reactive Programming

Tue, 07 Apr 2015 03:32:33 +0100

In little less than a week, a new edition of Coursera’s course, Principles of Reactive Programming from Martin Odersky, Erik Meijer and Roland Kuhn, is launching.

This course is a follow-up of Principles of Functional Programming in Scala, which I took in its first edition and which I enjoyed a lot. I’ve regretted missing out first edition of this second course for a long time (more than a year, in fact), so if you want to learn about this magnificent frameworks of the Scala world, don’t miss this chance!

And best of all, it’s free!

Java 8 and Functional Programming

Thu, 02 Apr 2015 10:54:58 +0100

Purpose of this post is to provide a glimpse of the new features included in Java 8 that shift this language towards a more Functional Programming paradigm. But before, let’s define what we understand for Functional Programming (FP). Functional programming key characteristics include:

Higher Order Functions
Pure Functions and Immutability
Tail Call Recursion

Higher Order Functions for a FP language means that functions are considered first class citizens, allowing the programmer to use them as any other value the language defines, for example, a Function value:

can be assigned to a variable defined with a proper type
can be passed or returned to/from another functions, allowing functions to be composed or _curried_ (partially applied).

Pure Functions are those functions that don’t produce side effects. Instead of directly modifying data structures within the function body, those data structures are returned as result of the invocation. This behaviour results in Immutable data structures, which are far less error prone than classical mutable data structures.

Tail Call Recursion allows a compiler to reuse a call stack frame in a recursive algorithm, making the execution behave (in terms of memory allocation) as if it were an iterative algorithm. Instead of allocating new stack frames for every recursive call, if the structure of the call follows an specific pattern, the compiler then can reuse same frame, making possible the use recursion without any increase in program’s memory footprint.

So, what does Java 8 include in order to make FP paradigm closer to the programmer? The key feature included in this release is are Lambda Expressions.

But what’s a Lambda Expression? Well, it just a syntactic sugar included in the language, reducing the amount of code needed to work with anonymous classes. Lambdas’ its syntax kind of reminds of a closure or monad, but let’s better see an example of a lambda:

 System.out.println("Hello Lambdas!");

But, as previously said, this could also be defined as anonymous class, as this is just syntactic sugar (let’s assume that LambadInterface is an already defined interface with one method apply):

new LambdaInterface {
   @Override
   public void apply() {
      System.out.println("Hello... Lambdas?");
   }
};

Not quite the same? Let’s evolve these pieces of code a little bit further:

 System.out.println("Hello Lambdas!");
lamdba.apply(); // Hello Lambdas!

LambdaInterface lambda = new LambdaInterface {
   public void apply() {
      System.out.println("Hello... Lambdas?");
   }
};
lamdba.apply(); // Hello... Lambdas?

How do Lambdas differ from FP Closures? Well, a closure is an anonymous function packed with the context where it was defined, being able to modify it’s context (context defined variables are, in fact, closed) . Java 8 Lambdas can access external context variables but only if they’re defined as final or if the programmer assures that they are not going to change their value (are actually final).

We said that Function Composition is also another key characteristic of FP, so, are Lambdas composable? Let’s see an actual example of Lambdas composition in action:

 n * 2;
Function&lt;Integer, Integer&gt; increment = (n) -> n + 1;

Function&lt;Integer, Integer&gt; doublePlusOne = duplicate.andThen(increment);

Unfortunately, Tail recursion is not included in Java 8, so we’ll still have to be cautious with memory consumption in recursive algorithms.

In future posts, we’ll deep into Lambdas and Functional Interfaces, and how they allow us to create a cleaner and more expressive code.

Groovy to be part of the Apache Software Foundation

Wed, 25 Mar 2015 19:06:15 +0100

As March 11th, Pivotal dropped its financial sponsorship for Groovy, and despite of not really endangering it, as Groovy is an already well established language with a great community backing it, it raised many concerns, as the required boost a platform like this deserves was missing until now. Furthermore, its creator and project leader until lately, Guillaume Laforge, also recently stepped back in order to focus in Restlet.

Also the recent release of Java 8, with the introduction of lambdas into the Java language has increased the interest and traction of Java, making a lot of people question if there were still room for other JVM languages, even more being so closed to Java.

So being worried about Groovy’s future is a normal consequence of this recent events. But don’t forget that this language has been community driven for a long time now, making this changes have a lower impact than initially expected.

So in order to clarify them, moving to the Apache Software Foundation has been a really smart move by the community, and as Cédric Champeu explains, a natural next step in Groovy’s lifetime that will help it weathering those changes.

This backup guarantees the position Groovy has as a trending alternative inside the JVM, making it still the most successful productivity booster and most enjoyable language, compared to the Old Java Language, within the JVM.

Further references:

http://groovy.dzone.com/articles/groovy-submitted-apache

Java 8 one year later

Mon, 23 Mar 2015 19:48:20 +0100

It’s been a little more than a year since Java 8 was released (2014/03/18) and you might think that it’s a little too late for a What’s new in post. In fact latest public update available is 8u40, so let’s review not only what was initially included in Java 8, but what else has changed during this first year, up to release 8u40.

Lots of changes were included in the initial Java 8 release, being probably the most notable of them, in my opinion (feel free to disagree, looking forward to discussions):

Java Language
- Lambda Expressions
- Method references
- Default methods
- Functional interfaces
- Method parameter reflection
- Optional references
API
- Collections Streams API
- Date-Time API (based on the popular Joda time library)
- Parallel Array Sorting
- Base64 encoding and decoding
- Unsigned Arithmetic Support
Tools
- Nashorn Script Engine – Javascript in the JVM
- Java Mission Control

… among many other optimizations, fixes and new capabilities. You can get a fully detailed changelog detail here.

We’re not going to go into further detail for these new characteristics, as you’ll find plenty of articles about them. Furthermore some of those would require entire books to proper explain and deal with them, and that’s not the purpose of this article.

But let’s review what has changed during this first year of Java 8’s life (up to 8u40 release). Again, these are the most important in my opinion:

New jdeps analysis tool
Advanced Management Console (AMC)
New Garbage Collection Tuning Guide added to JDK 8 documentation
SSLv3 disabled by default
Java Flight Recorder can be enabled in runtime

… and many other improvements and bugfixes.

And last but no least, we should talk about Java 8 adoption rate, which has been surprisingly higher than initially expected based on a Typesafe’s survey:

Interestingly, one of the conclusions extracted from that survey is that the inclusion of Lambdas in the Java language has not hurt Scala at all, but validated its approach to Functional Programming:

Other references:

Welcome to jvmGeek!

Fri, 20 Mar 2015 14:09:42 +0100

Welcome to jvmGeek!

This new blog aims to talk and discuss about the JVM ecosystem, with news and articles discussing about Java – the language -, and also about other JVM languages such as Scala, Kotlin or Clojure.

But it won’t deal only about programming languages, but also about tools and libraries. You’ll find news, tutorials, code examples and more general articles, among other.

From time to time I will also try to gather events and news related to one particular matter and post them as a flash post that will help you keep up to date with this effervescent platform.

I hope you’ll enjoy reading this blog as least as much as I did writing it!

Thank you very much!

Daniel Pecos (@danielpecos).

Using Chromebook for node.js development

Thu, 05 Mar 2015 15:54:50 +0100

Every single working day I spend between 2 and 2.5 hours in a train. And I feel pretty lucky about this, mostly because is one single train, no need to pay attention for switch overs or other kind of public transports, and that allows me to invest that time in whatever task I want: podcasts, videos, blogging or even programming. And that’s what I want this post to focus in, because there are plenty of posts that explain how to use a Chromebook for day-to-day tasks (even being offline) but not that many that talk about programming in node.js using a Chromebook.

There are two main challenges we have to figure out when using a Chromebook (CB) for usual programming tasks:

Connectivity
A proper development environment

Connectivity is a big issue because, despite of there are quite a few web IDEs or even environments that expose a whole virtual machine, they often require a connection in order to work.

On the other hand, as a developer I want to use the best tools possible in order to achieve my goals, a proper development environment, and that for me means having:

A linux shell
tmux (not a must, but really nice to have)
vim
git
node.js virtual machine (managed with nvm if possible)

It turns out that CB really suck in this point, so my idea when I bought this platform was to create a tiny partition and install a Linux OS there with all this requirements. But I was surprised when I heard about crouton: this amazing tool creates chroot environments within the very ChromeOS (which is a Linux underneath), where you can do whatever (well, almost) you want. All you need is root access (Developer mode in ChromeOS jargon) and some free space (but really not that much).

I’m not going to explain how to get this chroot environment up and running. There are plenty of posts and tutorials that explain this process. Just a quick spoiler: it’s super easy and takes no more than 15 minutes.

Once you have a chroot with at least crouton cli-extra, getting the rest of the tools up and ready is easy peasy. Use apt-get install to get tmux, vim and git, download nvm and fetch latest node.js binary. Integrate all of this into your bash scripts, so you don’t need to setup nvm with every login and you’re good to go.

< self-promotion >

Last but not least, setup your config files for vim, git, ssh, bash… or use one handy opensource tool (developed in node.js using a ChromeBook) call dotback. Just install it using npm:

npm install -g dotback

And setup your configuration definition file.

dotback --action install

Or if you already have done that and it’s available through a git repository, fetch it using:

dotback --action init REPO_URL

Takes a little bit to tune, but once it’s done, you’ll see the effort was worth of it.

< / self-promotion >

And that’s how I got a really portable box, with enough power for node.js development, and really really light, which is good if you have to carry it with you almost all the time 🙂

I hope you liked my Chromebook & Node.js feedback and that it helped you to decide if you’re thinking about getting a Chromebook or not, and as I was, were worried about being able to use it as a developer environment.

HTPC automatic workflow for Movies and TV Shows

Fri, 27 Feb 2015 06:40:51 +0100

Watching Movies and TV Shows from online streaming sources is a pain, as you depend on the availability of the your ISP network and current status of the stream provider. Furthermore, you don’t always have an internet connection available when you want to spend some time in front of the TV. So downloading it it’s a much better way to go in order to avoid this issues (giving that you have to anticipate a little bit to get downloads finished).

BTW, PopCorn Time is a recent solution that works pretty neat: it streams video directly fetched from torrent sources. I recommend giving it a try.

But looking for latest TV shows episodes or movies using torrent search providers is also a pain, because it requires a certain time and dedication you could spend in some other task.

But we’re computer engineers and we love automating things, and this specific problem we’re describing has to be more common than unusual, so I started googling about this matter and I found these pretty cool tools:

CouchPotato: tool that looks for movies in different torrent providers, fetching the appropriate torrent based on your quality requirements as soon is ready. It integrates with IMDB via a browser plugin, so you can queue upcoming movies without even opening its interface.
flexget: really powerful tool that keeps track of your latest downloaded TV show episodes and fetches new ones (well, their torrents) as soon they’re available and meeting your quality requirements
filebot: renames, organizes and downloads subtitles for video archives based on their metadata and search results on internet video databases.
PushBullet: get notifications from other applications directly into your mobile device.
Kodi / XBMC: one of the best HTPC platforms, with lots of plugins and features.
TV Show Time: really nice social network and episode tracking site.

Let’s wire it all together! This is how they interact with each other in my current workflow:

Movies

I look for movies in IMDB and when I find any of interest, I queue that one into CouchPotato using its browser plugin (available for Chrome and Firefox).
CouchPotato keeps looking for torrent sources for queued movies and whenever one is available, it queues it to the download list and I get a notification in my cell phone.
Once the file is ready, filebot attaches proper metadata & subtitles and moves / renames that file to its final destination and tells Kodi to refresh its library.
Kodi (previously known as XBMC) reloads a set of preconfigured directories (where filebot places files) from time to time and gets new videos stored into its database, fetching art work and IMDB / TV Shows DB info if required.

TV Shows

Flexget keeps looking for existing / returning TV shows I’m interested in (and previously configured in its config file), getting notified as when they’re in the torrent download queue
Rest of the steps for this workflow are exactly the same as for movies.
One difference but, is that once I finish watching that episode, Kodi automatically marks it as watched in my TV Show Time account.

So after expending some time setting this workflow up and integrating these tools into my HTPC, I got a totally automated TV Show / Movies box. I totally recommend that you expend some time with these tools. Once running you can almost forget about looking for torrents ever more.

Awesome!

UPDATE: Here you can find a nice tutorial on How to Use Kodi: What You Need to Know

From Node.js back to Java

Wed, 22 Oct 2014 12:33:19 +0100

During last year, I had the chance to work as CTO of a startup, working mainly within MEAN stack. I was happy, the technology I was working with was in a great hype and its community grew bigger and bigger with lots of projects popping up everywhere.

But life is continuously changing, and I started to work in a new company within Java/JEE technologies. I was back to my first days as a professional computer engineer. Java ecosystem is huge, and there are some well established tools that you must control if you want to progress as Java developer. But Java -the language- is getting older, and newer languages are more expressive and require less boiler plate code (don’t get me wrong, JVM is a great platform, and probably the best one for enterprise applications). Even with the recent release of Java 8, which introduced Lambdas and some functional style capabilities, I still feel like writing too much, or at least much more than with other languages.

You could ask yourself then why did I change?

Not long ago JVM included some bytecode instructions that allowed scripting languages to be run within it. That turn the JVM into a polyglot ecosystem, with languages like Groovy, Scala or Clojure gaining traction, attracting more users into it and making its community more vibrant than ever.

We’re living a Functional Renaissance, where OOP is not the only solution one would dare to apply any more. And probably its flagships are Scala and Clojure, both JVM based (whereas there are implementations of Scala for .NET platform, its origin and biggest user base is using JVM version).

And this transformation happening within the JVM was the main reason I wanted to come back. It’s a perfect moment to be there and worth of losing daily touch with Node.js (at least in my job, because I still love this technology and its community). JVM is a great platform, has great tools, and now finally, has some great languages.

Functional programming in javascript: Function composition

Tue, 24 Jun 2014 06:30:07 +0100

Function composition is one the key features (among others) of functional programming. Programming languages that offer higher order functions as a feature can potentially use function composition. But, still, programmers need to be aware of some key concepts to successfully apply this pattern in our code.

Function composition, as defined on Wikipedia, is an act or mechanism to combine simple functions to build more complicated ones. In other words, we can define new functions, equivalent to the result of chaining a set of given functions, so the input of function i is the output (or result) of function i-1. Let’s see an example in javascript.

Having these two functions:

function double(x) {
   return x*2;
}

function triple(x) {
   return x*3;
}

We define sixtimes as the composition of the two previous:

function sixtimes(x) {
   return double(triple(x));
}

Obviously in this case it would have been easier just to multiply x by 6 inside sixtimes, but let me continue with this dumb example just to get to the concept.

This pattern is going to be used widespread in functional programming, so one could define a compose function that would return a new function resulting of the composition of two given:

function compose(f, g) {
   return function(x) {
      return g(f(x));
   }
}

Now, using compose to define our previous function sixtimes, would be as easy as:

var sixtimes = compose(triple, double);

Isn’t it beautiful?

In following posts I will show you some gems extracted from Javascript Allongé by Reginald Braithwaite, where the author explains some useful composition tips and a really nice concept he calls Function decorators. (Update: after digging a little bit, I found this concept comes from Python world, where the very syntax allows you to list decorators for functions in its definition)

Until then you’re welcome to take a look at my presentation slides and code I used during a talk in a Ruby local users group (valencia.rb) comparing OOP and FP:

Slides (mix of Spanish and English, sorry!)
Code

Who is who in computer science

Wed, 28 May 2014 03:32:21 +0100

I have problems remembering people’s names. Really, I’m not good at it. And that’s no exception with computer technology. That’s why I’ve written this post, to try to improve and persist those names in my head. Let’s see who is who in nowadays computer science.

Methodologies

  <div>
    <strong>Kent Beck</strong> (<a href="http://en.wikipedia.org/wiki/Kent_Beck">wikipedia</a>, <a href="https://twitter.com/KentBeck">twitter</a>) &#8211; XP, Agile, TDD
  </div>
</td>

<td width="50%">
  <a href="http://martinfowler.com/"><img class="alignleft" src="/assets/2014/05/martin_fowler.png" alt="martin_fowler" width="100" height="85" /></a><strong><a href="http://martinfowler.com/">Martin Fowler</a> </strong>(<a href="http://en.wikipedia.org/wiki/Martin_Fowler">wikipedia</a>, <a href="https://twitter.com/martinfowler">twitter</a>) &#8211; OOP, Agile, TDD
</td>

  <div>
    <strong>Robert Cecil Martin &#8211; <em>Uncle Bob</em></strong> (<a href="http://en.wikipedia.org/wiki/Robert_Cecil_Martin">wikipedia</a>, <a href="https://twitter.com/unclebobmartin">twitter</a>) &#8211; Software Craftmanship, Agile Manifesto
  </div>
</td>

<td width="50%">
  <a href="http://martinfowler.com/"><img class="alignleft" src="/assets/2014/05/j-b-rainsberger.jpg" alt="j-b-rainsberger" width="100" height="100" /></a><strong><a href="http://www.jbrains.ca/">J. B. Rainsberger</a> </strong>(<a href="http://en.wikipedia.org/wiki/J._B._Rainsberger">wikipedia</a>, <a href="https://twitter.com/jbrains">twitter</a>) &#8211; Agile
</td>

Mike Cohn (wikipedia) – Scrum

Technology and Languages

<td width="50%">
  <img class="alignleft" src="/assets/2014/05/dijkstra-300x233.jpg" alt="dijkstra" width="100" height="78" /></p>

  <div>
    <p>
      <strong>Edsger W. Dijkstra</strong> (<a href="http://en.wikipedia.org/wiki/Edsger_W._Dijkstra">wikipedia</a>) &#8211; Sortest Path Algorithm
    </p>
  </div>
</td>

<td width="50%">
  <img class="alignleft" src="/assets/2014/05/james-gosling-300x200.jpg" alt="james-gosling" width="100" height="67" /></p>

  <div>
    <strong>James Gosling</strong> (<a href="http://en.wikipedia.org/wiki/James_Gosling">wikipedia</a>) &#8211; Java
  </div>
</td>

<td width="50%">
  <img class="alignleft" src="/assets/2014/05/matz-199x300.jpg" alt="matz" width="67" height="100" /></p>

  <div>
    <strong>Yukihiro &#8220;<em>matz</em>&#8221; Matsumoto</strong> (<a href="http://en.wikipedia.org/wiki/Yukihiro_Matsumoto">wikipedia</a>, <a href="https://twitter.com/yukihiro_matz">twitter</a>) &#8211; Ruby
  </div>
</td>

<td width="50%">
  <img class="alignleft" src="/assets/2014/05/ryan.jpg" alt="ryan" width="98" height="100" /></p>

  <div>
    <strong>Ryan Lienhart</strong> Dahl &#8211; Node.js
  </div>
</td>

Tim Berners-Lee (wikipedia) – HTTP

  <div>
    <strong>Linus Torvalds</strong> (<a href="http://en.wikipedia.org/wiki/Linus_Torvalds">wikipedia</a>) &#8211; Linux
  </div>
</td>

<td width="50%">
  <a href="http://www.stroustrup.com/"><img class="alignleft" src="/assets/2014/05/Bjarne-Stroustrup.jpg" alt="Bjarne-Stroustrup" width="100" height="75" /></a><strong><a href="http://www.stroustrup.com/">Bjarne Stroustrup</a> </strong>(<a href="http://en.wikipedia.org/wiki/Bjarne_Stroustrup">wikipedia</a>) &#8211; C++
</td>

Rasmus Lerdorf (wikipedia, twitter) – PHP

Guido van Rosum (wikipedia, twitter) – Python

Brendan Eich (wikipedia, twitter) – Javascript

Books

Well, those here are not strictly people, but books and their writers.

  <div>
    <strong>Design Patterns: Elements of Reusable Object-Oriented Software</strong>  &#8211; <em><strong>Gang of Four</strong></em>
  </div>
</td>

<td width="50%">
  <img class="alignleft" src="/assets/2014/05/The_pragmatic_programmer-238x300.jpg" alt="The_pragmatic_programmer" width="80" height="100" /></p>

  <div>
    <strong>The Pragmatic Programmer: From Journeyman to Master</strong>
  </div>
</td>

  <div>
    <strong>Clean Code: A Handbook of Agile Software Craftsmanship<br /> </strong>
  </div>
</td>

<td width="50%">
  <img class="alignleft" src="/assets/2014/05/the-clean-coder-231x300.jpg" alt="the-clean-coder" width="77" height="100" /></p>

  <div>
    <strong>The Clean Coder: A Code of Conduct for Professional Programmers (Robert C. Martin Series)<br /> </strong>
  </div>
</td>

  <div>
    <strong>Code Complete: A Practical Handbook of Software Construction, Second Edition<br /> </strong>
  </div>
</td>

<td width="50%">
  <img class="alignleft" src="/assets/2014/05/javascript_patterns-227x300.jpg" alt="javascript_patterns" width="76" height="100" data-recalc-dims="1" /></p>

  <div>
    <strong>JavaScript Patterns<br /> </strong>
  </div>
</td>

  <div>
    <strong>JavaScript: The Good Parts</strong> &#8211; <a href="http://www.crockford.com">Douglas Crockford</a>
  </div>
</td>

<td width="50%">
  <img class="alignleft" src="/assets/2014/05/javascript_allonge-232x300.jpg" alt="javascript_allonge" width="77" height="100" data-recalc-dims="1" /><br /> <img class="alignleft" src="/assets/2014/05/Reg-Braithwaite-300x300.png" alt="Reg-Braithwaite" width="100" height="100" data-recalc-dims="1" /></p>

  <div>
    <strong>Javascript Allongé</strong> &#8211; <a href="http://braythwayt.com/">Reg Braithwaite</a>
  </div>
</td>

Do you miss some one? No problem, leave a comment and I’ll update this post.

Organizing your Code: Javascript Modules

Thu, 08 May 2014 12:35:09 +0100

The way you structure your code is a key factor when you define your source code organization. It will make your life easier or miserable, and once this structure is established it will become a really tedious task to redefine it. That’s why you know about the different patterns available and choose the one fits your project best.

But, why should I care about modules? Well, is the way Javascript offers to organize and encapsulate your code, and if you don’t think you need to do it, because maybe it’s a small project or you don’t care at all, trust me, you are making a huge mistake!

Let’s start talking about what a module really is, and talking about Javascript modules is talking about Javascript scope: the only way to achieve privacy in Javascript code is enclosing the private code in a closure (an IIFE – Immediately Invoked Function Expression):

(function() {

  // your code goes here

})();

And this is exactly all we are going to need to create blocks of encapsulated code, hidden one from another. But modules as we know them today are a little bit more: modules are ways of defining chunks of code that are dynamically loaded.

Currently there are three main different ways of defining a module:

AMD

Format proposed by Dojo. Uses XHR and eval to dynamically load code, allows defining module dependencies and has a great support for browser loaders (require.js, curl.js). It also can be used in server-side with require.js:

AMD module definition

// foo.js

define("foo", ["bar"], function(bar) {

return function() { ... };

});

AMD module requirement

// app.js

require(["foo"], function(foo) {

...

});

Common.JS

Born from a group of volunteer aiming to standardize modules and packages in Javascript. This is the pattern used by Node.js, but it’s also supported in browsers using curl.js or SproutCore:

CJS module definition

// foo.js

exports.foo = function() { ... }

CJS module requirement

// app.js

foo = require("./foo").foo

ES6 / ES Harmony

Next version of the language incorporates some new features, including, among others, a standard way to define and consume modules:

ES6 module definition

// foo.js

module foo {

  export var foo = function() { ... };

}

ES6 module requirement

// app.js

module foo from "./foo" // remote URLs also allowed here

import * from foo;

Conclusion

AMD & CommonJS have a wide support, but in my opinion, each of them have a slightly different approach: AMD seems to fit better in browser-side (it’s inherently asynchronous) and CommonJS seems to fit better in server-side, where synchronously loading code is a choice. Of course, you can use third libraries to use them in whatever environment, but it doesn’t seem the natural way.

There are some hybrid approaches, so you don’t have to pick any them, but both, but this only makes things harder and difficult to follow.

Luckily, ES6 modules are (or will be) part of our day-to-day, so I strongly suggest this should be the way to go. Currently, browser support for ES6 modules is only achieved via transpilers or libraries, so we’ll have to wait a little bit longer to use this feature. V8 implementation is still incomplete, so no luck neither in server-side.

Until then, you’ll still have to choose a pattern to go with. I recommend you not to enter this holy war, but just to pick one of them and keep coding great stuff.

Bibliography:

Node.js blog: NodeGeek

Tue, 06 May 2014 17:54:48 +0100

Javascript is an old well-known friend that is growing rapidly and gaining traction since Node.js, a command line Javascript interpreter based on Chrome V8 Javascript Virtual Machine, was published. Its community is building great stuff, and more and more companies are moving into this stack, with a high success ratio.

http://nodegeek.net

Luckily for me, for my last two professional years I have been involved in one way or another with it, been able to relearn the language and discover its framework. And since not long ago, I’ve been writing articles for a new site where I could focus about this amazing programming stack:

Until this very moment I have post some quite successful posts related to its history or its package system, and many more are almost ready to be published.

So if you are interested in this technology I would suggest you to subscribe to its mailing list in order to be noticed for latest published posts. Or follow its twitter account! And if you think you could collaborate with this project, don’t hesitate to contact me!

Create and publish an NPM module

Thu, 13 Mar 2014 18:07:28 +0100

Code modularization, achieved in one way or another, is a technique a good developer must aim for because it helps keeping things small, well-tested and organized. And of course, it follows the DRY directive. So as a Node.js developer (and maybe contributor to the Open Source), creating and publishing an NPM module is one of those steps you will eventually face.

Probably if any Node.js developer would have to pick an indispensable tool of the ecosystem, npm would win by far. Its greatness resides in how much easy is to build applications using on of several modules, each of them providing one certain functionality, as if they were building bricks, picking the right tool for each task.

But, how difficult is the process of creating an NPM module? Well, here is a cheat sheet to get this done:

Create a directory with the name of the module and place your code in it. How you structure your content is up to you. The index file will define your external API (module’s exports), the functionality other developers can reach of your module.
If you never logged in into npm (usually you don’t need to do it unless you want to push some content into NPM repository), this would be your next step:
```
$ npm adduser

$ npm login
```
Initialize your module and fill in the required information:
```
$ npm init
```
Don’t forget to install all your dependencies so they appear in the package.json manifest:
```
$ npm install whaterver-module --save
```
Once you have set up your package.json file, you’re ready to make it public. Increase the version number of you module and publish it:
```
$ npm publish
```
Now you’ll be able to find it in the NPM repository:
```
$ npm search test-module-dpecos
```
Optionally, tag your GIT repository with current version number. It makes easier to guess what was included with each release of your module.

And that’s it!, your package will soon appear in NPM registry search results (it it hasn’t already), allowing other developers to find and use it.

Whenever you want to publish and update of one of your already published modules, these are the steps you should follow:

Increase your module’s version number
Publish it again
Optionally, tag your GIT repository with current version number

You have to take care about version numbers:

You can’t repeat them
You can’t publish a lower version number than the previously published version
You can follow any scheme to designate your version number, but there are some of them considered standard

But sometimes, software gets old, deprecated or replaced by a better one. If, sadly, this is the case for your module, you can remove it from NPM registry with these command:

$ npm unpublish

And it will be gone forever 🙁

If you want to get an deeper knowledge of npm commands, I recommend you to visit the official CLI docs.

Node.js ecosystem

Wed, 08 Jan 2014 20:38:59 +0100

The Node.js ecosystem is quite young and prolific: new tools appear almost every day or week, changing and turning upside down your current workflow, always trying to squeeze a little more productivity to your time and effort or simply making your work easier.

As an example, take a look on the NodeFramework page, where Azat Mardanov (@azat_co) collects lot’s of frameworks and utilities related to Node.js. Or NodeWebModules, more web oriented than the previous one, from Caio Ribeiro Pereira (@crp_underground).

Let’s start with the basics:

node and npm. node is the command line Javascript interpreter and it’s the core for the whole ecosystem. npm on the other hand, is a tool to manage that ecosystem, allowing you to install new modules and tools, and keeping them up to date. Although npm is not tightened to node, it’s provided with the default Node.js installation package, making it the defacto Node.js module manager.

But npm is not only a module manager: it’s also a great tool to manage a node project dependencies, taking care of recursive dependencies and resolving collisions between modules. You can take a look to all its capabilities in this great tutorial from Isaac Z. Schlueter (@izs).

Anyone can create and share npm modules, making the ecosystem bigger and bigger. At this moment npm repository has around 54K packages ready to download, and its growth rate is faster than other’s ecosystems (see also this link):

Packages per day across popular platforms (Source: www.modulecounts.com)

The current state of art of the Node.js ecosystem include, among others, these tools as the most popular ones, in my opinion:

CoffeeScript
Grunt
Express
Mocha
PM2

But I’m sure that many other tools and modules deserve to appear in this top 5 list. It’s so nice and funny to keep discovering new jewels every single day, isn’t it?

Node.js and V8 history

Thu, 19 Dec 2013 06:15:38 +0100

Talking about Node.js history, it’s talking a little bit about V8 history. But let’s start with a one line definition of what it is: Node.js is a platform built around Google Chrome V8 Javascript engine, to create lightweight, fast, scalable, event-driven and non-blocking I/O applications. So lets begin talking about Node.js origins, the V8 javascript engine.

V8 is an opensource project by Google and it is in the very core of Google Chrome browser. Its first public release was on September 2, 2008, same date Chrome’s first release was announced. It was a big step forward in browsers’ performance, and it pushed browsers’ technology to a new whole level. It’s written in C++ and its biggest revolution was that it precompiled the Javascript source code to machine code instead of just interpret it and then applied a JIT process again in runtime to improve dynamic code execution.

Ryan Dahl – Creator of Node.js

Then, around 2009, Ryan Dahl was trying to solve a tough problem in that days: making the browser know how much time of an upload process was left. Inspired by Ruby’s Mongrel webserver and by the recent release of Chrome and V8, he decided to give Javascript a chance, creating the seeds that would transform in short time into Node.js.

The project has been develop and sponsored by Joyent, company where Ryan was working. Nowadays he is still working there, but has stepped back, delegating the gatekeeper position to Isaac Schlueter on January 30, 2012.

If you are interested in further details about Ryan Dahl and how and why he decided to create Node.js, here you have a video of himself talking about that:

Historically, Javascript browser environments are limited to just one execution process / thread, making impossible to update DOM and execute some business logic simultaneously, and this also applied to V8, so, why someone would be interested in such limited and poor performance platform to run in a server environment?

Well, truth is that maybe Javascript is not the most calculation efficient language available, but its event-driven non blocking design, makes Node.js one of the lightweight platforms (runs really well in a RaspberryPI) and more performant web platforms, competing directly with the old JEE Java Platform, PHP and Ruby.

From a developer perspective, the amount of innovation the Node.js community is creating is simply astonishing, and that’s also because one of the three other key tools a Node.js developer must known: NPM.

But this is a story we will address another day.

References:

http://en.wikipedia.org/wiki/Nodejs
http://en.wikipedia.org/wiki/V8_(JavaScript_engine)
https://code.google.com/p/v8/

Hello world! Node.js & Javascript blog

Mon, 16 Dec 2013 13:35:57 +0100

Wellcome to this new site where you’ll find lots of information about Node.js, Javascript and HTML 5 technologies!

This project is a chance for me to share my passion about these new and amazing technologies, trying to make you easier to step into it and to discuss and enjoy technology talks to whomever who wants to.

It will be mainly focused on Node.js, but sometimes we will talk about generic Javascript or even frontend Javascript related to HTML5 capabilities.

And if you consider yourself kind of a Node.js guru or simply would like to participate, please just contact me and you will be very welcome to collaborate.

Hope you enjoy this content as much as I enjoyed creating it!

Pssst!! Don’t forget to follow us in twitter!

Daniel Pecos Martínez (@danielpecos)

Javascript Allongé: a review

Mon, 04 Nov 2013 16:02:50 +0100

Javascript Allongé@raganwald is one of the more refreshing coding books I have read in a big while. Usually when I face a programming language book, I skip the beginner chapters (if I already know the language, of course) and go directly for the juicy ones, but with this one I tried to follow it from end to end because I read some comments on twitter telling that the way basics are explained, become a really solid base for the language, so I gave it a chance.

And they were right! This book is not the usual Learn the language in 24 hours or something like that. It’s actually a very sharp and deep reading about Javascript and function composition.

The way the author explains how to create really simple functions and use them to build more complex ones just blowed my mind. The resulting code is so clear and easy follow that is almost impossible to imagine a better way to express that functionality.

This book is a total recommendation if you deal with Javascript in your day-to-day. I bought a digital copy in Leanpub, but recently the author made it opensource, so you’re free to get a copy of it:

Buy it: https://leanpub.com/javascript-allonge
Buy it (Kindle): Amazon
Read it online: https://leanpub.com/javascript-allonge/read
Get the sources: https://github.com/raganwald/javascript-allonge

RaspberryPi shutdown button

Mon, 30 Sep 2013 15:57:55 +0100

Last Friday I got some spare time (finally!) and, with the help and tools of my friend Alfredo, we placed a button in the RaspberryPi case so, when I push it, a custom command its executed on the RaspberryPi, like for example, a clean system shutdown.

First lets start with some pictures of the final result:

And now the schematics (pins used in the schematics are 3.3v, GND and GPIO):

We mainly followed this post, but used a different GPIO port, we soldered the components (once we tested the schematics on a protyping board) and modified the code to launch a custom command. This is the resulting code we used to do a system shutdown (I removed some comments from the original code of the post):

import os
import time
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setup(4,GPIO.IN)

prev_input = 0
while True:
  input = GPIO.input(4)
  if ((not prev_input) and input):
    os.system("sudo halt")
  prev_input = input
  #slight pause to debounce
  time.sleep(0.05)

The line highlighted is the one you should modify to set your custom command. To test it, you have to execute it as root:

$ sudo python gpio_button.py

and press the button. Finally, to launch this code in the startup process, just add it to /etc/rc.local (just before the exit 0):

$ sudo vi /etc/rc.local

Easy peasy!

Next steps: modify the program to detect single click, double-click and long click.

Madrid – OpenSpace Persistencia

Sat, 19 Jan 2013 20:31:50 +0100

Persistencia ha sido el tema tratado en el OpenSpace que se ha realizado en las oficinas de tuenti. Hemos podido hablar sobre temas como NoSQL, ActiveRecord, BD basados en grafos, geoespaciales, … entre otros muchos. Ha habido mucho debate, con muchas opiniones, pero sobre todo muy buen ambiente.

Muy interesante la charla que ha dado la gente de tuenti sobre como gestionan la persistencia. Es de agradecer la claridad y transparencia con la que han participado.

Dar las gracias a @borillo por el esfuerzo en la organización del evento y a tuenti por ofrecer sus oficinas para el evento.

Os recomiendo que en cuanto tengáis la oportunidad, acudáis a un OpenSpace siempre resulta una actividad muy gratificante y en la que seguro aprenderás algo nuevo.

Javascript Promises Pattern in plain Javascript

Wed, 16 Jan 2013 13:05:01 +0100

In the previous post I gave a glimpse of the Javascript Promises Pattern (JPP). Now we are going to take a more in deep look into it and implement our (simplified) version of this pattern.

First of all, let’s sow the code I we defined works: we had three operations (to make the example simpler, they all share the same code, but this is not a requisite), each of them expecting a set of arguments which are processed by an asynchronous operation. The result of this asynchronous operation will be feed to the next operation, and so on until we achieve processResults function that will handle the final result. This is a refactored version of the code exposed in the previous post:

function operation(params) {
  var promise = new Promise(this)
  async_task(params, function() {
    // ...
    promise.resolve(params);
  });
  return promise;
}

function processResults(results) {
  // ...
}

operation1 = operation;
operation2 = operation;
operation3 = operation;

operation1(params1).then(operation2).then(operation3).then(processResults);

Every operation creates a promise object that will be returned as result of the invocation to the operation. Furthermore, this promise object is used to store the future value that will result from the asynchronous call. This value is stored in the promise object using the resolve method.

operation1(params1).then(operation2).then(operation3).then(processResults);

This line is were all the magic is done: we invoke the first operation, which returns a promise object, and over this object we are invoking the then method, passing a function as its argument, which will be invoked when the promise object is resolved. Then we repeat this invocation to the then method in order to chain more callbacks, each of them being invoked by successive promise resolve invocations.

This may appear simple, but it’s kind of tricky: we pretend to receive the results of every operation as argument of the following callback. That works ok for operation1, but promises objects from operations 2 and 3 still don’t exist so there is no way to attach those promises to its correspondent callback. In other words, invoking the then method of the promise object doesn’t actually invoke operation2 and operation3 (in fact, the parameters they need are still not available). What really happens is that they are chained into the operation1 promise object.

operation1: return promise1
-> invoke then (operation2): return promise1
-> invoke then (operation3): return promise1

So how does JPP resolve this? Well, the trick can be discovered paying attention to the instantiation of the promise objects: we passed this as first argument, which in fact turns to be global object Window for promise1 and operation1 promise object for the promise2 and promise3 instantiations. That’s because resolve method invokes callbacks functions applying itself as the current scope. Maybe it’s easier to see in code:

function Promise(promise) {
    if (promise instanceof Promise) {
        return promise;
    } else {
        // this is a new promise chain
        this.callbacks = [];
    }
}

Having this idea clear, we can try to develop our own implementation for this pattern. We already have defined the constructor function, let’s go for the then and resolve methods:

Promise.prototype.then = function(callback_ok) {
    this.callbacks.push({
        ok: callback_ok
    });
    return this;
};

Promise.prototype.resolve = function() {
    var callback = this.callbacks.shift();
    if (callback && callback.ok) {
        callback.ok.apply(this, arguments);
    }
};

As we said, then just store the function to call when the resolve method is invoked. resolve then just pops the callback function to invoke, applying current promise object (this) as its scope, so when the next operation tries to create a new promise object, it gets the actual promise object instead of a new one, which turns to be the one used to define the chain of callbacks.

Well, better than to read code to understand it, is to play with it, so here you have a fiddle ready to go. It’s a litlle more complex implementation than the exposed here, because I defined a reject method, but the main idea stands.

I would love to hear feedback from you about the pattern itself or the implementation, so don’t hesitate to post comments!

Javascript Promises Pattern – 101

Tue, 08 Jan 2013 11:03:59 +0100

I am sure you have heard about the javascript Promises Pattern, but if you haven’t, here is a quick and simple definition: a promise or future is an object that represents a future result, not yet obtained or calculated (here you have a more complete definition). In fact, what is really nice about it is that allows you to define callbacks for async code in and more elegant and readable way.

But wait a moment, what’s the problem with the actual callbacks system? Well, they work, but they become a big mess when you try to chain two or more of them, resulting in a code looking like a pyramid. Let’ see an example.

Suppose you have several async operations: operation1, operation2 and operation3 and they must be execute in strict sequence, that is, operation 2 must wait for operation1 to finish and so on. The resulting code will look like something like this:

operation1(params1) {
  async_task(params1, function() {
    operation2(params2) {
      async_task(params2, function() {
        operation3(params3) {
          async_task(params3, function() {
            // here we have the results of the three operations
          }
        }
      }
    }
  }
}

This code is, at least, hard to follow and thus to understand (and in my opinion quite ugly), but it has been the common way to deal with asynchronism in javascript… until now. Look how the same code would look like using Promise Pattern:

function operation1(params1) {
  var promise = new Promise()
  async_task(params1, function() {
    // ...
    promise.resolve(params2);
  });
  return promise;
}

function operation2(params2) {
  var promise = new Promise(this)
  async_task(params2, function() {
    // ...
    promise.resolve(params3);
  });
  return promise;
}

function operation3(params3) {
  var promise = new Promise(this)
  async_task(params3, function() {
    // ...
    promise.resolve(allResults);
  });
  return promise;
}

function processResults(allResults) {
  // ...
}
operation1(params1).then(operation2).then(operation3).then(processResults);

Here you can clearly see that there are three different operations, that don’t appear to be tight one to another. The chainability of the three functions is established in the last line of code, making it clear with a glimpse that every operations depends on the result of the previous one, and thus, they must be executed in strict order. This line is the key of the Promise Pattern and it works because every operation return a promise object. We’ll deep into this in further posts.

This code can be heavy refactored, but I prefer to keep it like this to make it easy to understand how promises work. Anyway, I think you will agree with me that this code is much elegant and easy to understand than the previous one.

So far, so good. In further posts I will show you how to easily implement this pattern in plain javascript, and we will deep into the tricks that promises use to make this code work. By the moment enjoy using the implementations provided by the main javascript libraries (much more powerfull than the one we will create) like jQuery’s deferreds (they are the same concept as promises).

See you in following posts!

Retrospectiva 2012

Mon, 31 Dec 2012 16:02:37 +0100

31 de Diciembre, otro año más. Y uno nuevo a punto de llegar.

En mi caso es fácil resumir 2012 en un par de palabras: cambio y aprendizaje. Ha sido un año en el que profesionalmente he tomado un cambio de dirección y del cual estoy realmente satisfecho, aunque en su momento fue una decisión díficil, sobre todo por el momento de crisis en el que nos encontramos. Y es que este cambio me ha hecho aprender. Mucho.

Ha sido el año en el que he descubierto el Agilismo como técnica de trabajo, y que me ha permitido conocer muchos otros puntos de vista, distintos y muchos de ellos muy interesantes. Y esto me ha permitido hacerme una auto-crítica (o retrospectiva) de la cual puedo sacar una idea muy clara: más cambio. Y es que, pesar de las técnicas que he podido descubrir y de las tecnologías que he podido aprender, solo he encontrado una constante: Nunca dejes de aprender, lo que hoy sabes, cambiará, y debes estar preparado. No le tengas miedo y abrázalo como un reto constante.

Esto es más cierto, si cabe, en la informática, ya que el cambio ocurre en plazos realmente cortos, y los cambios que avecinan parecen no ser pequeños. ¿Quién me iba a decir a mi en Enero de este año que terminaría habiendo hecho formaciones sobre Agilismo y Scala y que el hype tecnológico a finales de año se centraría en HTML5 y Javascript? No way… pero así es, y la verdad es que es un mundo realmente emocionante el que nos espera este próximo año.

Aunque sin duda el cambio más importante que he experimentado este año no se puede definir en palabras:

Izan – 2012 / 10 / 11

¡Feliz año 2013!

Valencia – Global Day of Coderetreat 2012

Sat, 08 Dec 2012 18:36:29 +0100

Creo que la mejor forma de iniciar este post es felicitando a los organizadores (@borillo, @xaviuzz, hay que reconocer que os lo habéis currado) y dando las gracias a peerTransfer por hacer de host para este evento de forma totalmente altruista.

Una pena para aquellos que no hayan podido asistir: ha resultado ser un evento muy dinámico, con opiniones y puntos de vista muy variados e interesantes y, sobretodo, divertido.

El problema a resolver (Conway’s Game of Life), aunque simple en principio, ha dado mucho juego, y aunque un pomodoro no es suficiente para implementar una solución completa, ni mucho menos, ha sido la excusa perfecta para practicar pair programming, TDD y ya de paso, poner en práctica algún nuevo lenguaje y herramientas.

¿Qué más se puede esperar de un Sábado de programación por el mero placer de programar y aprender?

Y ahora a ver si consigo implementar una versión del juego medianamente completa, que al final me he quedado con las ganas. ¡Esto es puro vicio!

http://coderetreat.org/events/global-day-of-coderetreat-valencia-spain

Functional Programming & Scala course finished

Tue, 13 Nov 2012 09:12:15 +0100

Coursera Functional Programming has not been my first experience in an online course, but it has been the most satisfying by far. Many people were interested in it, and I think it created a great hype, not only in the course forums but in social networks like twitter. People all around the world were interacting in the same course, creating really interesting conversations and discussions about the subject. Really nice.

Technically speaking, the course has consisted in an introduction Functional Programming principles and a more in deep look to the Scala language. But, in my opinion, one of the key points in this course was the lessons format: between 1 hour and 1.5 per week of video and slides from the professor Martin Odersky and one home assignment.

The difficult of the assignments were in crescendo, making them a really funny challenge every week (I remember a couple of days staying up until really late at night because I was in flow with the current assignment and didn’t want to stop it).

In conclusion, high quality content, teacher and classmates, really interesting stuff about FP and Scala and, more important, a really satisfying experience (nothing compared to the online course I took at the UNED, and for what I paid a considerable amount of money).

PD: Did I mention that this Coursera FP & Scala course was for free? Thank you very much Coursera and Pr. Martin Odersky (and stuff)!

Looking forward to a continuation course!

References:

Coursera Functional Programming Course

Recipe: From SVN to Git without pain

Fri, 13 Jan 2012 18:33:49 +0100

Are you already in love with Git? I’m pretty sure of that, that’s the reason why you are reading this, huh?

These are the steps you should follow to migrate an existing SVN repository to a Git one:

1 – Create a file where you will map SVN users to Git users, following this pattern:

svn_user = git_user

This is the one I created to migrate some SVN repositories from Google Code:

$ cat authors_mapping_googlecode
dpecos = Daniel Pecos Martinez
(no author) = Daniel Pecos Martinez

The author (no author) is required to match some commits made by Google in the SVN repository creation process.

2 – Now let’s import code from SVN:

git svn clone --username svn_user --authors-file=authors_mapping --no-metadata -s svn_url git_repo_path_tmp

The one I used to import my np-lib project was:

git svn clone --username dpecos --authors-file=authors_mapping_googlecode --no-metadata -s https://np-lib.googlecode.com/svn/ np-lib_tmp

We can go into the just created Git repository and display its log in a pretty tree format:

$ git log --graph --decorate --pretty=oneline --abbrev-commit

3 – Next step is to clone this repository into a new one, just get ride of all SVN junk created by git-svn:

$ git clone git_repo_path_tmp git_repo_path<br /> $ rm -rf git_repo_path_tmp<br /> $ cd git_repo_path<br /> $ git remote rm origin

4 – We are ready, but maybe you want to push your repository to GitHub (or any other one), so what you’ll need to do as follows:

(At this point I suppose that you have created a Git repository in GitHub and that you have already setup your environment to push content to it, if not, you will have troubles from now on)

$ git remote add remote_name git_url

In my case it was:

$ git remote add github git@github.com:dpecos/NP-Lib.git

Some clarifications about this last command: many people use as default remote Git repository name “origin“, me too, but in this case, GitHub wasn’t my default remote Git repository, but I private one so I decided to create a “github” remote.

Now we only have to push local content to the remote repository:

$ git push remote_name master

Which in my case was:

$ git push github master

And that’s all, we got a Git repository set up and ready to work with GitHub starting from a SVN one.

Hope this recipe will help you. Time to enjoy!

Blog rollback

Fri, 30 Dec 2011 16:27:03 +0100

A couple of months ago I took the decision to reset my blog and start it again from the beginning, creating a more professional computer technology oriented content. I wrote some technical articles and I feel really proud of them, but there was something left, some place where I could write about my thoughts or anything I would think it would deserve it.

Some days ago I make a quick revision of a backed up previous blog where I found some articles I liked very much, some of them with several comments, containing really interesting stuff, and some others that were really crap articles. I started thinking that maybe the restart of the blog was not a good decision, that what my blog really needed was a good clean up and not a complete reset. And that’s what I’ve been doing for a couple of days, recovering articles that I feel are interesting or that made me feel in some special way when I wrote them.

Now I am proud to present this refurbished version of my previous blog and the more recent one. It contains technical content, personal stuff, opinion articles and more written in Spanish and English. To make this change more noticeable, I have decided to give it a new name: dpmWare, just my stuff, nothing else (just to show the influence of my recent blog Debug yourself! Simply code, just that). I’m also planning to apply a new style to the site so maybe you’ll see some changes in a few days.

Of course I will continue writing technical articles and finish some series of articles still pending. I hope you will enjoy these articles at least as much as I enjoyed writing them.

Daniel Pecos Martinez

PS: Happy new year 2012!

Git-SCM (Part 2)

Sun, 28 Aug 2011 18:34:04 +0100

In a previous post, we have seen what Git is and its main characteristics. Now, we’ll go more into detail about its functionality and we’ll see what a usual day working with Git looks like.

But before, some initial concepts:

Repository: A working tree of files and directories which can be versioned, keeping track of every single modification made over the working tree, been able to move forward and backward in its history.
Branch: it is an alternative image of the repository, keeping track of its own history of modifications. A repository has a main branch called master, and it can have an undefined number of branches, some of them may be copies of remote branches and the default name for the upstream repository is origin. The current branch of the working copy can be always referenced as HEAD.
Commit: it is a concrete state of a branch, containing the modifications made to the entire working tree since the previous commit in the history, as well as author information and timestamps. It can be identified by its SHA hash, but a name or tag can be associated to it in order to make thing easier.
Merge: it is the process of integrating changes or commits of two different branches. This integration is automatically carried by Git, if there are no conflicts between commits.
Push: the changes committed in a local branch into a remote branch.

These are the basic concepts we are going to use in the rest of this post. Now let’s start with the fun!

Setting up the repository: initialize and importing

First step is to create or to obtain a repository. In order to create a fresh new repository, this is the instructions we need to execute:

mkdir hello_world
cd hello_world
git init

Alternatively, we can grab an already initialized remote repository with these instructions:

git clone git://url.to/hello_world
cd hello_world

A Git repository is a normal directory that contains a .git directory inside, where all the necessary information to track changes will be stored.

Modifications: status, adding, committing and reverting

Once we have our repository ready to work (we can check that its clean by using the command status):

$ git status
# On branch master
#
# Initial commit
#
nothing to commit (create/copy files and use "git add" to track)

we can start to work in the current directory, creating, modifying and deleting files and directories as we need to. For example, I will create a Hello World! in java (but a more complex one than the usual, to prove how to work with several files). First of all, I’m going to create two separate folders: one for sources and other for classes. Then I will create an empty Greetings.java and a HelloWorld.java and then I will make a commit with the initial structure:

mkdir src bin
touch src/Greetings.java
touch src/HelloWorld.java
git add –A

Now we can check the status of the current working tree and see that there are changes pending to be committed:

$ git status
# On branch master
#
# Initial commit
#
# Changes to be committed:
# (use "git rm --cached ..." to unstage)
#
# new file: src/Greetings.java
# new file: src/HelloWorld.java
#

So let’s commit these modifications. Every commit needs a commit message that identifies the contents of this commit:

$ git commit –m "Initial commit: project structure and source files created"
[master (root-commit) 8738922] Initial commit: project structure and source files created
0 files changed, 0 insertions(+), 0 deletions(-)
create mode 100644 src/Greetings.java
create mode 100644 src/HelloWorld.java

Ok, we have our prune project ready to be coded. Now it is time to type the necessary code to get the result expected, so open Greetings.java and HelloWorld.java with your preferred editor and paste the following code:

Greetings.java

public class Greetings {

	public int sayHello() {
		System.out.println("Hello World!");
	}
}

HelloWorld.java

public class HelloWorld {

	public static void main(String[] args) {
		Greetings g = new Greetings();
		g.sayHello();
	}
}

Now if we check the status of the working tree, we can see that these two files have modifications pending to be committed:

$ git status
# On branch master
# Changes not staged for commit:
# (use "git add ..." to update what will be committed)
# (use "git checkout -- ..." to discard changes in working directory)
#
# modified: src/Greetings.java
# modified: src/HelloWorld.java
#
no changes added to commit (use "git add" and/or "git commit -a")

Let’s commit it, it is a Hello World, what could it be wrong, huh?

$ git commit –a –m "Java code for Greetings and HelloWorld classes"
[master 18e6ec5] Java code for Greetings and HelloWorld classes
 2 files changed, 13 insertions(+), 0 deletions(-)

Now we can see that our repository history has two commits:

$ git log
commit 18e6ec54628a5f01f6beda8b30c64f61ab23585a
Author: Daniel Pecos Martinez
Date:   Sun Aug 28 22:42:45 2011 +0200

    Java code for Greetings and HelloWorld classes

commit 8738922a6193fbbeb4bcb67e663b0403a8fbdace
Author: Daniel Pecos Martinez
Date:   Sun Aug 28 19:33:36 2011 +0200

    Initial commit: project structure and source files created

And if we want to see a diff output of the current HEAD revision with its previous commit we can do like this:

$ git diff HEAD^1
diff --git a/src/Greetings.java b/src/Greetings.java
index e69de29..aeff26c 100644
--- a/src/Greetings.java
+++ b/src/Greetings.java
@@ -0,0 +1,6 @@
+public class Greetings {
+
+       public void sayHello() {
+               System.out.println("Hello World!");
+       }
+}
\ No newline at end of file
diff --git a/src/HelloWorld.java b/src/HelloWorld.java
index e69de29..cbc10da 100644
--- a/src/HelloWorld.java
+++ b/src/HelloWorld.java
@@ -0,0 +1,7 @@
+public class HelloWorld {
+
+       public static int main(String[] args) {
+               Greetings g = new Greetings();
+               g.sayHello();
+       }
+}
\ No newline at end of file

Time to test it! Compilation is the first step (as you know for sure ;-)):

$ javac src/Greetings.java -d bin/

$ javac src/HelloWorld.java -d bin/ -cp bin/
src\HelloWorld.java:6: missing return statement
        }
        ^
1 error

Ups! There was an error :-S Well, that one is easy to fix: let’s change return type of main method to void:

$ javac src/HelloWorld.java -d bin/ -cp bin/
$ java -cp bin/ HelloWorld
Hello World!

So now everything seems fine, but our working tree is not clean, we have our last modifications pending to commit. But, if I commit them and I publish the repository, everyone could see what a fool I am because of that silly mistake, what should I do? Well, I ’ll try to hide my failure so I will amend last commit and include modifications made later:

$ git commit -a --amend
[master a612cb0] Java code for Greetings and HelloWorld classes
 2 files changed, 13 insertions(+), 0 deletions(-)

$ git log
commit a612cb025664304586609700b9874eab19aab8b1
Author: Daniel Pecos Martinez
Date:   Sun Aug 28 22:42:45 2011 +0200

    Java code for Greetings and HelloWorld classes

commit 8738922a6193fbbeb4bcb67e663b0403a8fbdace
Author: Daniel Pecos Martinez
Date:   Sun Aug 28 19:33:36 2011 +0200

    Initial commit: project structure and source files created

Perfect! I have included the necessary fix for my bug and nobody will notice it, great! But wait… my current working tree is not clean:

$ git status
# On branch master
# Untracked files:
#   (use "git add ..." to include in what will be committed)
#
#       bin/
nothing added to commit but untracked files present (use "git add" to track)

Well, these are the files resulting from compilation, so they can be deleted (in fact, is not correct to commit them), but this will happen again and again, any time I compile my project and don’t delete the resulting classes. The way to avoid this is to tell Git to ignore certain files that match a defined pattern, defined in a special file .gitignore:

$ cat > .gitignore
bin/*

$ git status
# On branch master
# Untracked files:
#   (use "git add ..." to include in what will be committed)
#
#       .gitignore
nothing added to commit but untracked files present (use "git add" to track)

Done! now the only thing left is to commit the just created file (I let this to you, so you can practice a little bit with git)

That’s all folks! (for now ;-)). In following posts I will try to explain how to work with branches (remote and local) and how to resolve conflicts, as well as some nice tools provided by git.

amCharts Javascript Tutorial: Parsing dates and styling up the chart

Thu, 31 Mar 2011 06:44:00 +0100

Recently I began a collaboration with amCharts, writing some tutorials for their blog. This is my first contribution, and you can find the original post in amCharts blog.

http://blog.amcharts.com/2011/03/amcharts-javascript-tutorials-part-3.html

I hope you’ll enjoy my first tutorial about this great graphs library! And, of course, feedback is wellcomed!

In this tutorial we will enhance our previous example in order to parse dates. This will allow us to obtain date-based graphs displaying their data points using relative distance to each other and not placing them at regular spaces.

We will apply some modifications to our previous example from Part 2, so if you haven’t read that part, you should at least get the example source code that you can find at the end of the tutorial. Furthermore, you will need amCharts package. Once you’ll have it unzipped, you have to copy amcharts/javascript folder to your working directory (the rest of directories are not needed for this example).

Now we are ready. Let’s start!

HANDLING DATES IN OUR DATA SOURCE

The very first step we need to accomplish in this tutorial is to create a function that converts date strings into Date objects. This could be achieved with the following code, where we define a function which requires a string with YYYY-MM-DD date format as first parameter, and returns a Date object created from that date string:

// method which parses a date string in the format YYYY-MM-DD and creates a Date object
function parseDate(dateString) {
     // split the string get each field
     var dateArray = dateString.split("-");
     // now lets create a new Date instance, using year, month and day as parameters
     // month count starts with 0, so we have to convert the month number
     var date = new Date(Number(dateArray[0]), Number(dateArray[1]) - 1, Number(dateArray[2]));
     return date;
}

Next we have to locate the exact point in our previous example where this conversion should be done. If you remember, in Part 2 we set up a handler called parseCSV to manage data loaded via an XMLHttpRequest. This is the perfect place to convert the date strings into javascript Date objects (I have removed some lines of code in order to focus on the changes):

// method which parses csv data
function parseCSV(data){
     // ...
     // loop through all rows
     for (var i = 0; i < rows.length; i++){
          // this line helps to skip empty rows
          if (rows[i]) {
               // our columns are separated by comma
               var column = rows[i].split(",");
               // column is array now
               // first item is date
               var date = parseDate(column[0]);

     // ...

Now the data provider contains Date objects instead of strings. Next step is to configure the category axis of the chart to properly manage Date objects: this is achieved setting the property parseDates of the axis to true:

var catAxis = chart.categoryAxis;
catAxis.parseDates = true;

These lines have to be added to the createChart function, just like this:

// method which creates chart
function createChart(){
     // chart variable is declared in the top
     chart = new AmCharts.AmSerialChart();
     // here we tell the chart name of category
     // field in our data provider.
     // we called it "date" (look at parseCSV method)
     chart.categoryField = "date";
     // now we have to set up the category axis to parse dates
     var catAxis = chart.categoryAxis;
     catAxis.parseDates = true;

     // chart must have a graph
     var graph = new AmCharts.AmGraph();
     // graph should know at what field from data
     // provider it should get values.
     // let&#39;s assign value1 field for this graph
     graph.valueField = "value1";
     // and add graph to the chart
     chart.addGraph(graph);
     // &#39;chartdiv&#39; is id of a container
     // where our chart will be
     chart.write(&#39;chartdiv&#39;);
}

If we launch our HTML file in the browser, we should get the following result:

Hey, wait a moment! Our graph has changed! That’s because our data has different size time gaps between data points, and now amCharts is able to understand dates in our data, rendering them in their relative position.

If we want to draw a graph like the previous one (using regular intervals between data points), we have to set to true the property equalSpacing of the category Axis:

// now we have to set up the category axis to parse dates
var catAxis = chart.categoryAxis;
catAxis.parseDates = true;
catAxis.equalSpacing = true;

And now the resulting graph looks more like the one we got in Part 2 of this tutorial series, but now the labels on the category axis are displayed using a date format, instead of using directly the string from our data:

MAKING-UP OUR CHART

To finish this Part 3 of our amChart Javascript turorials, we will style-up our chart to get a fancier one. All the following code has to be added to the already defined createChart function.

First of all we will apply some general styles to the chart so we can set up margins, set a general color and add an initial animation:

// styles applied to the chart
// default general color used in the chart
chart.color = "#AAAAAA";
// length of the animation
chart.startDuration = 2;
// margins between graph and canvas border
chart.marginLeft = 15;
chart.marginRight = 80;
chart.marginBottom = 40;

Then we will style both axes. We will set our category axis to use bluish colors for the axis and grid lines:

// styles applied to the category axis
// color of the axis line
catAxis.axisColor = "#2d66bb";
// color of the grid lines
catAxis.gridColor = "#2d66bb";

To set up the value axis, we need an instance of ValueAxis, but we haven’t created one until now, so our first step is to get a fresh instance. Then, in a similar way as before, we will set our value axis using also bluish colors but this time we don’t want to show the grid lines, just the background colors. Finally, we add our new styled value axis to the chart:

// styles applied to value axis
// we haven&#39;t set up a value axis until now,
// so we create one and apply styles to it
var valAxis = new AmCharts.ValueAxis();
// we want to display the value axis on the right side
valAxis.position = "right";
// color of the axis line
valAxis.axisColor = "#2d66bb";
// as we set fillAlpha, and fillColor we don&#39;t want grid to be visible
valAxis.gridAlpha = 0;
// each second gap between grid lines will be filled with this color
valAxis.fillColor = "#2d66bb";
// fill alpha
valAxis.fillAlpha = 0.1;
// length of each dash
valAxis.dashLength = 3;
// and finally we add the value axis to the chart
chart.addValueAxis(valAxis);

Last step is to apply some styles to our graph line:

// styles applied to the graph line
// color of the graph line
graph.lineColor = "#3a81ec";
// thicknes of the graph line
graph.lineThickness = 2;
// show round bullets for each point
graph.bullet = "round";
// length of each dash
graph.dashLength = 1;

And the resulting chart should look like this one:

Here you have full source code as it should look like once all changes we have talked about in this tutorial have been applied:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
        <title>amCharts Example</title>
        <link rel="stylesheet" href="style.css" type="text/css">
        <script src="javascript/amcharts.js" type="text/javascript"></script>
        <script src="javascript/raphael.js" type="text/javascript"></script>
        <script type="text/javascript">
        // declaring variables
        var chart;
        var dataProvider;
        // this method called after all page contents are loaded
        window.onload = function() {
            createChart();
            loadCSV("data.txt");
        }
        // method which loads external data
        function loadCSV(file) {
            if (window.XMLHttpRequest) {
                // IE7+, Firefox, Chrome, Opera, Safari
                var request = new XMLHttpRequest();
            }
            else {
                // code for IE6, IE5
                var request = new ActiveXObject(&#39;Microsoft.XMLHTTP&#39;);
            }
            // load
            request.open(&#39;GET&#39;, file, false);
            request.send();
            parseCSV(request.responseText);
        }
          // method which parses a date string in the format YYYY-MM-DD and creates a Date object
          function parseDate(dateString) {
               // split the string get each field
               var dateArray = dateString.split("-");
               // now lets create a new Date instance, using year, month and day as parameters
               // month count starts with 0, so we have to convert the month number
               var date = new Date(Number(dateArray[0]), Number(dateArray[1]) - 1, Number(dateArray[2]));
               return date;
          }
        // method which parses csv data
        function parseCSV(data){
            //replace UNIX new line
            data = data.replace (/rn/g, "n");
            //replace MAC new lines
            data = data.replace (/r/g, "n");
            //split into rows
            var rows = data.split("n");
            // create array which will hold our data:
            dataProvider = [];
            // loop through all rows
            for (var i = 0; i < rows.length; i++){
                // this line helps to skip empty rows
                if (rows[i]) {
                    // our columns are separated by comma
                    var column = rows[i].split(",");
                    // column is array now
                    // first item is date
                    var date = parseDate(column[0]);
                    // second item is value of the second column
                    var value1 = column[1];
                    // third item is value of the fird column
                    var value2 = column[2];
                    // create object which contains all these items:
                    var dataObject = {date:date, value1:value1, value2:value2};
                    // add object to dataProvider array
                    dataProvider.push(dataObject);
                }
            }
            // set data provider to the chart
            chart.dataProvider = dataProvider;
            // this will force chart to rebuild using new data
            chart.invalidateData();
        }
        // method which creates chart
        function createChart(){
            // chart variable is declared in the top
            chart = new AmCharts.AmSerialChart();
            // here we tell the chart name of category
            // field in our data provider.
            // we called it "date" (look at parseCSV method)
            chart.categoryField = "date";
            // styles applied to the chart
            // default general color used in the chart
            chart.color = "#AAAAAA";
            // length of the animation
            chart.startDuration = 2;
            // margins between graph and canvas border
            chart.marginLeft = 15;
            chart.marginRight = 80;
            chart.marginBottom = 40;
            // now we have to set up the category axis to parse dates
            var catAxis = chart.categoryAxis;
            catAxis.parseDates = true;
            //catAxis.equalSpacing = true;
            // styles applied to the category axis
            // color of the axis line
            catAxis.axisColor = "#2d66bb";
            // color of the grid lines
            catAxis.gridColor = "#2d66bb";
            // styles applied to value axis
            // we haven&#39;t set up a value axis until now,
            // so we create one and apply styles to it
            var valAxis = new AmCharts.ValueAxis();
            // we want to display the value axis on the right side
            valAxis.position = "right";
            // color of the axis line
            valAxis.axisColor = "#2d66bb";
            // as we set fillAlpha, and fillColor we don&#39;t want grid to be visible
            valAxis.gridAlpha = 0;
            // each second gap between grid lines will be filled with this color
            valAxis.fillColor = "#2d66bb";
            // fill alpha
            valAxis.fillAlpha = 0.1;
            // length of each dash
            valAxis.dashLength = 3;
            // and finally we add the value axis to the chart
            chart.addValueAxis(valAxis);
            // chart must have a graph
            var graph = new AmCharts.AmGraph();
            // graph should know at what field from data
            // provider it should get values.
            // let&#39;s assign value1 field for this graph
            graph.valueField = "value1";
            // and add graph to the chart
            // styles applied to the graph line
            // color of the graph line
            graph.lineColor = "#3a81ec";
            // thicknes of the graph line
            graph.lineThickness = 2;
            // show round bullets for each point
            graph.bullet = "round";
            // length of each dash
            graph.dashLength = 1;
            chart.addGraph(graph);
            // &#39;chartdiv&#39; is id of a container
            // where our chart will be
            chart.write(&#39;chartdiv&#39;);
        }
        </script>
    </head>
    <body style="background-color:#EEEEEE">
        <div id="chartdiv" style="width:600px; height:400px; background-color:#FFFFFF"></div>
    </body>
</html>

HTTP connection + HTTP Authenticacion + Proxy + SSL

Wed, 08 Dec 2010 17:20:19 +0100

Many times during your life as a java developer, you will face the situation of retrieving some resources using an HTTP connection. At first, it will seem easy, but probably some problems will arise such as:

Needing to use an HTTP Proxy (maybe authentication would be required)
Establishing an HTTP authenticated connection
Connecting to a server that uses SSL self-signed certificates

I’m sure you will quickly find the Apache Commons solution: commons-httpclient. In this article I will show you some code that, I hope, will ease you the resolution of the previous obstacles using this great API from Apache.

First of all I will show you the basic code needed to establish an HTTP GET connection using commons-httpclient and then we will add continuous enhancements step by step:

GetMethod httpget = null;
String result = null;
try {
    httpget = new GetMethod(url);

    HttpClient client = new HttpClient();
    int status = client.executeMethod(httpget);
    if (status == 200) {
        result = httpget.getResponseBodyAsString();
    } else {
        System.err.println("Error accessing to URL " + status + ": " +  httpget.getStatusLine());
    }

} catch (MalformedURLException e) {
    System.err.println("Malformed URL: " + e.getMessage());
} catch (IOException e) {
    System.err.println("I/O problems: " + e.getMessage());
} catch (Exception e) {
    System.err.println("URL not found: " + e.getMessage());
} finally {
    if (httpget != null) {
        httpget.releaseConnection();
    }
}

1. Use an HTTP Proxy (maybe authentication would be required)

Now lets add the necessary code to establish the HTTP connection using a Proxy. I will use a static method to configure proxy settings in our HttpClient instance:

private static void configureProxy(HttpClient client, HttpMethodBase method, String proxyHost, int proxyPort, String proxyUsername, String proxyPassword, String proxyNTDomain) {

    client.getHostConfiguration().setProxy(proxyHost, proxyPort);

    if (proxyUsername != null && proxyUsername.length() &gt; 0) {

        if (proxyNTDomain != null && proxyNTDomain.length() &gt; 0)  {
            // use NT Domain authentication
            NTCredentials credentials = new NTCredentials(proxyUsername, proxyPassword, proxyHost, proxyNTDomain);
            HttpState state = client.getState();
            state.setProxyCredentials(new AuthScope(proxyHost, proxyPort, AuthScope.ANY_REALM), credentials);
        } else {
            // use plain user/password authentication
            Credentials defaultcreds = new UsernamePasswordCredentials(proxyUsername, proxyPassword);
            client.getState().setProxyCredentials(new AuthScope(proxyHost, proxyPort, AuthScope.ANY_REALM), defaultcreds);
        }
        method.setDoAuthentication(true);
    }

}

and then we will have to insert this line of code in our previous example (I have inserted it between lines 6-7):

configureProxy(client, httpget, proxyHost, proxyPort, proxyUsername, proxyPassword, proxyNTDomain);

At this moment, we have point 1 solved, so let’s go for point 2: Basic HTTP Authentication.

2. Establish an HTTP authenticated connection

In order to keep code as clean as possible, I will create another static method to set HTTP authentication:

private static void configureHTTPAuthentication(HttpClient client, String host, int port, String httpUsername, String httpPassword) {
    client.getState().setCredentials(new AuthScope(host, port), new UsernamePasswordCredentials(httpUsername, httpPassword));
}

and the required call to this method, just after the previous one:

configureHTTPAuthentication(client, httpget.getURI().getHost(), httpget.getURI().getPort(), httpUsername, httpPassword);

This one was easy 😉

3. Connect to a server that uses SSL self-signed certificates

Now lets solve the last point, probably the more difficult of all of them. We will need two implementations of ProtocolSocketFactory and X509TrustManager that accept self-signed certificates: EasySSLProtocolSocketFactory and EasyX509TrustManager, which you can find in httpclient-contrib (I have grabbed them from Adrian Sutton and Oleg Kalnichevski and you can also find them attached at the end of this article). Once in our classpath, we have to insert the following code in our first example, just below the call to configureHTTPAuthentication:

if (url.startsWith("https")) {
    Protocol protocol = new Protocol("https", new EasySSLProtocolSocketFactory(), 443);
    client.getHostConfiguration().setHost(httpget.getURI().getHost(), 443, protocol);
    // we also can set this socketfactory as global for all the connections
    //Protocol.registerProtocol("https", protocol);
}

Finally, we should be able to connect to a HTTP-Authenticaded SSL URL, using an http (authenticated-?)proxy. Isn’t it cool? This is how our final code looks like:

private static void configureProxy(HttpClient client, HttpMethodBase method, String proxyHost, int proxyPort, String proxyUsername, String proxyPassword, String proxyNTDomain) {

    client.getHostConfiguration().setProxy(proxyHost, proxyPort);

    if (proxyUsername != null && proxyUsername.length() &gt; 0) {

        if (proxyNTDomain != null && proxyNTDomain.length() &gt; 0)  {
            // use NT Domain authentication
            NTCredentials credentials = new NTCredentials(proxyUsername, proxyPassword, proxyHost, proxyNTDomain);
            HttpState state = client.getState();
            state.setProxyCredentials(new AuthScope(proxyHost, proxyPort, AuthScope.ANY_REALM), credentials);
        } else {
            // use plain user/password authentication
            Credentials defaultcreds = new UsernamePasswordCredentials(proxyUsername, proxyPassword);
            client.getState().setProxyCredentials(new AuthScope(proxyHost, proxyPort, AuthScope.ANY_REALM), defaultcreds);
        }
        method.setDoAuthentication(true);
    }

}

private static void configureHTTPAuthentication(HttpClient client, String host, int port, String httpUsername, String httpPassword) {
    client.getState().setCredentials(new AuthScope(host, port), new UsernamePasswordCredentials(httpUsername, httpPassword));
}

public static String doGETConnection(String url, String proxyHost, int proxyPort, String proxyUsername, String proxyPassword, String proxyNTDomain, String httpUsername, String httpPassword) {

    GetMethod httpget = null;
    String result = null;
    try {
        httpget = new GetMethod(url);

        HttpClient client = new HttpClient();
        configureProxy(client, httpget, proxyHost, proxyPort, proxyUsername, proxyPassword, proxyNTDomain);
        configureHTTPAuthentication(client, httpget.getURI().getHost(), httpget.getURI().getPort(), httpUsername, httpPassword);

        if (url.startsWith("https")) {
            Protocol protocol = new Protocol("https", new EasySSLProtocolSocketFactory(), 443);
            client.getHostConfiguration().setHost(httpget.getURI().getHost(), 443, protocol);
            // we also can set this socketfactory as global for all the connections
            //Protocol.registerProtocol("https", protocol);
        }

        int status = client.executeMethod(httpget);
        if (status == 200) {
            result = httpget.getResponseBodyAsString();
        } else {
            System.err.println("Error accessing to URL " + status + ": " +  httpget.getStatusLine());
        }

    } catch (MalformedURLException e) {
        System.err.println("Malformed URL: " + e.getMessage());
    } catch (IOException e) {
        System.err.println("I/O problems: " + e.getMessage());
    } catch (Exception e) {
        System.err.println("URL not found: " + e.getMessage());
    } finally {
        if (httpget != null) {
            httpget.releaseConnection();
        }
    }

    return result;

}

Possible exceptions

But, if we haven’t been lucky, we can find one of this two exceptions (if not both) when trying to establish connection:

javax.net.ssl.SSLHandshakeException: sun.security.validator.ValidatorException:PKIX path building failed: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target

This one is due to the JDK can not verify the self-signed certificate. We have to add it to a trusted keystore and make it available to the JDK, using InstallCert java standalone application.

Another different problem that I got while developing this code, was the next one:

javax.net.ssl.SSLKeyException: RSA premaster secret error

It’s related to this size of the certificate and the JDK cryptographic capabilities. To resolve this issue, download and install the Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files version 5.0. Extracted from its README file:

Due to import control restrictions, the version of JCE policy files that are bundled in the JDK(TM) 5.0 environment allow “strong” but limited cryptography to be used. This download bundle (the one including this README file) provides “unlimited strength” policy files which contain no restrictions on cryptographic strengths.

Please note that this download file does NOT contain any encryption functionality since such functionality is supported in Sun’s JDK 5.0.Thus, this installation applies only to Sun’s JDK 5.0, and assumes that the JDK 5.0 is already installed.

And finally…

I hope this article would help you to resolve your HTTP connection issues. If not, please post a comment and I will try to reply you ASAP. You can also find me at twitter @danielpecos

Feedback is welcomed!

Files used for this demo:

Full sources of the example developed here: httpclient-example.
Standalone java application to create a keystor__e: InstallCert.
I also provide a mirror for the needed policy files in case of RSA premaster secret error.

Git-SCM (Part 1)

Thu, 18 Nov 2010 21:03:11 +0100

One of the key tools of a software project development is the repository where it’s hosted. During my experience as software developer I have been working with several flavors, such as Visual SourceSafe, CVS, Mercurial, and of course, SVN. But latetly I have found this little jewel called Git.

Git was initially developed by Linus Torvalds as a result of an unsuccessful research to replace the propietary SCM BitKeeper, used back in 2005 in the Linux Kernel project (kinda strange that the opensource star project was hosted with a propietary software, huh?). Back then, the ability to freely use BitKeeper was withdrawn by its copyright holder, so Linus was forced to find a replacement for it. He was looking for a VCS with a high performance in the process of applying patches and keeping track of the changes, but he didn’t find any opensource solutions that fitted his requirements, so he started the developement of Git (as he says on Git’s Wikipedia entry, Git was named after himself, because he considers himself an “egoistical bastard, and I name all my projects after myself”; git is the British English slang word for an stupid or unpleasant person).

That’s why its main characteristics are oriented to help the development and management of a huge, distributed and collaborative project like the Linux Kernel. These are the most noticeable of them:

Strong support for non-linear development
Distributed development
Efficient handling of large projects
Cryptographic authentication of history
…

But for me, the most shocking one is its decentralized structure in distributed development: there is no need for a central repository where all commits are sent by the people working in the project (but still, it is recommended to use a main branch for that purpose).

In following posts I will explain how to use Git in the lifecycle of a software project and how can it improve our performance.

Nuevo foro de fotografía: enfocas.es

Wed, 07 Oct 2009 11:26:50 +0100

http://enfocas.es

En origen, ENFOCAS, está formado por un grupo de amig@s de Castellón, unidos por su pasión hacia la fotografía. El foro en sí, nace como punto de encuentro de quienes como nosotros, sientan la necesidad de compartir esta afición, a través de las imágenes que podamos aportar, junto con los comentarios, dudas, informaciones de interés o cualquier otro aspecto que pueda surgir a lo largo de su vida.

No pretendemos ser ningún referente, tan solo queremos disponer de una parcela de la red para poder compartir nuestra pasión por la fotografía, con quienes quieran acercarse a él, y lo hagan de forma respetuosa hacia las obras, aportaciones y opiniones de los demás.

Precisamente en este talante de respeto hacia las aportaciones, grandes o pequeñas, y de las opiniones de sus componentes, esperamos que surja un foro vivo y participativo, donde el propio foro, su estructura, su estilo sea fruto de la participación de quienes lo componemos.

Por último, no podemos evitar tener presente en nuestro pensamiento, que la comunicación a través de Internet, aún siendo deseable y de gran importancia, no puede ni debe suplir, en la medida de lo posible, un contacto directo y personal. Tratamos, pues, de conseguir una participación más cercana, buscando fomentar la presencia activa a través de puntos de encuentro, ya sean mediante KDD´s en nuestra comunidad o fuera de ella, si fuera posible, y a través de todos aquellos birrings que nos permitan compartir unos momentos de amigable camaradería y conversación.

GNU HttpTunnel: Como saltarse un proxy HTTP

Wed, 02 Sep 2009 13:41:25 +0100

Creo que es la primera vez que posteo sobre una aplicación, pero creo que en este caso merece la pena hacerlo. Se trata de GNU HttpTunnel, una pequeña aplicación que crea un túnel HTTP sobre el que podemos meter cualquier servicio. ¿Ventajas? Pues que al ser HTTP, si nos encontramos en una red que solo tiene salida a Internet mediante un proxy HTTP, con esta aplicación (y un PC fuera de la red), podemos salir de la red con el servicio que más nos interese.

Aquí va el chuletario:

En el PC al otro lado del proxy (fuera de la red) ejecutamos:

$ hts -w -F host_remoto:puerto_remoto puerto_local_servidor

y en el cliente (detrás del proxy) ejecutamos:

$ htc -P ip_proxy:puerto_proxy -F puerto_local_cliente ip_servidor:puerto_local_servidor

Por ejemplo, si quisiera crear un tunel HTTP para el SSH que tengo en mi servidor de casa (cosa muy útil, por si tuviera que abrir nuevos túneles ;-)), tendría que ejecutar el siguiente comando en dicha máquina:

$ hts -w -F localhost:22 7022

lo cual crearía un tunel a la expera de conexión en el puerto 8022 del servidor (este puerto tendría que hacerlo accesible desde internet, en caso de que nos encontremos detras de un router sin NAT), y en la máquina desde la que me quiero conectar ejecuto:

$ htc -P ip_proyx:80 -F 22 ip_servidor:7022

de forma que ahora al conectarme al puerto 22 de la máquina local, realmente me estoy conectando al puerto 22 del servidor de mi casa.

Pues espero que os sea útil!

Un saludo!

Más info:

Adiós Gloria

Fri, 24 Apr 2009 18:48:48 +0100

Me ha costado bastante escribir este post, pero finalmente creo que el recuerdo lo merece.

Como homenaje, se están recogiendo firmas para dar su nombre a una de las aulas del ESTCE: http://homenajeagloria.uji.es/

El pasado 14 de abril de 2009 falleció nuestra compañera y amiga Gloria Martínez. Gloria fue una de las profesoras encargadas de poner en marcha en 1991, fecha de su creación, los estudios de informática en la Universidad Jaume I. Desde entonces ha estado involucrada, muy activamente, en todos los aspectos tanto organizativos como docentes de dichos estudios. También fue una de las personas más destacadas en muchas de las actividades extraacadémicas de esta Universidad como son, por ejemplo, las jornadas iParty, o el grupo de Amnistía Internacional de la UJI. Además, también destacó a nivel nacional como impulsora de la Asociación de Enseñantes Universitarios de Informática (AENUI) de la cual era Coordinadora en el momento de su fallecimiento.

Muchas de las personas que tuvimos relación directa con Gloria, tanto estudiantes como profesores y amigos, consideramos que ha dejado una gran huella allí por donde ha pasado y desearíamos que su memoria no se olvidase fácilmente en el lugar al que dedicó gran parte de su energía. Para ello, todas las personas abajo firmantes, solicitamos que se dé su nombre a una de las aulas de la ESTCE donde ella desarrolló su actividad docente.

Gloria, gracias por enseñarme como lo hiciste y ser como fuiste. Tus clases son de de los mejores recuerdos que mantengo de la universidad. Gracias.

(Si alguien quiere saber más sobre cómo era ella, aquí dejo la dirección de su blog donde posteaba con frecuencia: http://servidora.blogspot.com/)

2009: Odisea con el funcionariado

Tue, 13 Jan 2009 19:46:31 +0100

Tiemblo cada vez que tengo que tratar con un funcionario, es como si te echaran una maldición:

De entrada tienes pocas esperanzas de poder hacer el trámite a la primera, sin que te toque volver n-mil veces a tratar con el/la individu@ en cuestión.
Una vez te decides a intentarlo, siempre te queda la duda de si ir al edificio público en el que ejerce su profesión o si acudir directamente a la cafetería de al lado (lo cual me hace reflexionar si su profesión es aquella por la que recibe un sueldo, o la que ejerce donde pasa la mayor parte de su jornada laboral… puede ser un tema de reflexión bastante interesante).
Por último, si has tenido suerte, los astros se encuentran en la conjunción adecuada y encuentras al funcionario en su sitio, tienes que poner la sonrisa más agradable para que el/la personaje, con su cara de estreñido (o de “deja de joderme, que yo a ti no te voy a buscar a tu trabajo y me pongo a darte por el culo”), se digne a darte un trato poco despreciable y a conseguir un mínimo de información, que con suerte, puede llegar a ser hasta útil (porque hay veces que se contradicen, o mejor aún, se dedican a pasarse la pelota, osea tú, de unos a otros).

Posibles motivos de que esta gente se comporte de este modo:

Porque no les gusta lo que hacen: pues tuvieron que estudiar bastante tiempo y disputárselo entre muchos para conseguir lo que tienen, por lo que estoy más que seguro que conocían lo que se iban a encontrar (tal vez, con toda la idea, de tocarse las pelotas durante los restos).
Porque el sentimiento de seguridad y de ser intocables en el trabajo les hace descuidarlo: poco más que decir, si no rindes cuentas a nadie y tampoco te motiva lo que haces, es obvio que cada vez lo vas a hacer peor y con menos ganas (siempre existe la posibilidad de que se dejen el trabajo, pero también existe la posibilidad de que llueva hacia arriba).

Concretando, todo esto se solucionaría eliminando la permanencia asegurada de un funcionario en su puesto de trabajo e implantando unos controles y seguimientos de los rendimientos de su trabajo. ¿Por qué no se hace? Pues porque seguramente lo tendría que tramitar un funcionario y es probable que se le fundieran los sesos al intentar averiguar qué impresos son necesarios.

Como bien dice mi padre, un funcionario es alguien que hace un esfuerzo en un momento de su vida y se pasa el resto de ella descansando. O como dice un amigo funcionario, que entran a las 8 al puesto de trabajo, pero trabajar nunca se sabe a qué hora se comienza (igualito que en mi empresa 🙁 )

Y es que francamente, ¿quién no ha pensado que la tarea que realizan 5 funcionarios administrativos la podrían hacer perfectamente 1, como mucho 2, personas trabajadoras como cualquiera? Da la sensación que cuando entran les hacen un test de aptitud y a los que lo superan les rechazan para el puesto (de hecho, el amigo que he comentado justo antes, fue acusado de trepa por sus compañeros funcionarios porque rendía demasiado 😮 !?!?!?!?! 😮 ).

Nota: he intentado referirme concretamente a funcionarios de caracter administrativo, de los que te atienden tras un mostrador o mesa, aunque, por sorprendente que parezca, estoy convencido que hay funcionarios de gran calidad tanto personal como profesional, por lo que tampoco es correcto generalizar.

Ingeniero informático, to be or not to be?

Tue, 11 Nov 2008 12:13:46 +0100

Desde hace un par de semanas está circulando una convocatoria de huelga para los ingenieros informáticos. Según comentan en la web, esta huelga se debe a la exclusión de las titulaciones de Informática de las propuestas de en las que se proponen los títulos habilitados para ejercer distintas profesiones. Concretamente se atribuyen a la Ingeniería en Telecomunicaciones muchas (por no decir prácticamente todas) las funciones que ejerce un Ingeniero Informático. Según comentan en dicha web, el Ministerio de Educación justifica esta decisión argumentando que:

“La informática se trata de una materia transversal, por lo que no puede concentrarse en una titulación concreta”

La cuestión es que se está levantando mucho revuelo (en parte con razón) y está ciruclando mucha rumorología que hace poco bien. Como bien explica Enrique Barreiro (profesor de Ingeniería Informática en la Universidad de Vigo) en esta web, hay dos problemas que se están mezclando en toda esta rumorología:

El diseño de los nuevos títulos adaptados al Espacio Europeo de Educación Superior, y
La regulación de la profesión (que se nos asignen las atribuciones que ejerzamos).

(En esta imagen tenéis un resumen light de lo que comentan)

Dos problemas diferentes pero relacionados, y es que al parecer la adaptación no se ha llevado a cabo para el proceso de Bolonia debido a que la informática no es una profesión regulada. Entonces, ¿por qué no se regula la profesión de informática? Básicamente porque les resulta caro a los empresarios. Y es que ahora mismo el intrusismo laboral de nuestro sector es común, y lo peor, ampliamente aceptado por todos nosotros. ¿Os imagináis a un chaval que se haya leido un libro de arquitectura proyectando edificios? Claro que sí, por poder claro que puede y seguro que hay algún genio que es capaz de hacerlo, pero ¿se lo construirían sin una firma de un arquitecto? Claramente no.

En informática no es raro encontrar químicos, telecos, matemáticos, físicos, aficionados o cualquier otra cosa. Seguramente sean perfectamente capaces de realizar el trabajo que realizan, gracias a la experiencia adquirida y la formación no homologada que hayan recibido, pero esto sería impensable en otros sectores como Derecho, Industriales o Medicina (por capaz que fueras de desarrollar la tarea).

En resumen, mi inquietud personal es: ¿Por qué se me considera menos ingeniero que a un industrial? La respuesta es sencilla: por que no nos hacemos valer, triste pero cierto. No tenemos conciencia de grupo, somos individualistas por lo que nuestro poder sindical es nulo. Además, por lo mismo, no tenemos un Colegio Oficial que defienda la profesión, al contrario de como ocurre con otras profesiones.

En fin como buen informático no me queda otra que la resignación (o hablando claro, bajarme los pantalones y que me hagan lo que quieran que yo seguiré tragando lo que me toque)… Triste pero como no lo hagas, a la puta calle que seguro que hay otro informático detrás de ti (aunque tampoco es necesario que sea informático) que por menos dinero que lo que tu pides, tiene los pantalones más abajo.

GDD MAD 2008… ¡Estuve allí!

Sun, 28 Sep 2008 10:32:01 +0100

{.tt-flickr.tt-flickr-Medium}

Fue un día agotador, pero valió la pena. Mucha gente, mucho nivel (no tanto en los talleres, pero bueno) y muy buen ambiente. No voy a hacer más resumenes acerca del evento (ya he leído unos cuantos en un rato), simplemente recomendar que si tenéis la posibilidad de asistir al GDD MAD 2009 no dejéis pasar la oportunidad.

Temas principales sobre los que se hablaron:

Android (tema estrella sin duda)
Chrome
AppEngine
Gears
Opensocial

A continuación os dejo un enlace al álbum en flickr con las fotos que tomé.

¡Un saludo!

¿Look & Feel? ¿Qué es eso?

Wed, 03 Sep 2008 09:43:30 +0100

Éste es el aspecto de varias aplicaciones ejecutándose en Windows XP. Como se puede ver en la imagen últimamente las empresas optan por una diferenciación en cuanto a aspecto de la ventana (Look & Feel), perdiéndose la integración a la que estábamos habituados con el sistema operativo. De hecho, en la captura de pantalla, la única aplicación que mantiene el L&F de Windows XP es el Explorador de Ficheros.

Y tú qué opinas acerca de ésto: ¿es bueno? ¿es malo? ¿te la suda?

Google anuncia Chrome

Tue, 02 Sep 2008 06:49:09 +0100

Tras varios años de rumorología acerca de si Google iba a publicar un navegador web propio o no, finalmente se ha aclarado: su nombre es Chrome. Será un proyecto opensource basado en WebKit de Apple (el motor de renderizado de Safari) y según comentan, incluye un motor Javascript escrito desde cero, con el fin de mejorar el desempeño tanto en tiempo de ejecución como en consumo de memoria, con respecto a los navegadores que actualmente hay en el mercado. Otras características que incorpora son la navegación anónima, un sistema “Speed Dial” como el de Opera o una barra de autocompletado basada en el buscador.

¿Qué es lo que pretende Google con esto? Según ellos, aportan innovación de cara al usuario, aunque personalmente lo que quieren conseguir es convertir al navegador en un sistema operativo (bueno, a lo mejor es un poco exagerado, pero sí en una fuente completa de aplicaciones), ya que supongo que uno de sus puntos fuertes será el poder ser ejecutado sin barra de herramientas ni menús, al estilo de Prism de Mozilla, consiguiendo que las aplicaciones web tengan un aspecto de aplicación de escritorio. Además, con la inclusión de Gears en Chrome, se ofrece la posibilidad de que las aplicaciones web almacenen datos en el propio navegador, abriendo un gran abanico de posibilidades para la tecnología web.

Como nota curiosa, comentar que Google ha utilizado su estilo característico en la publicación de Chrome utilizando viñetas de cómic para ello.

Habrá que ver cómo afecta esto a los otros grandes navegadores y que implicaciones creará en el desarrollo de aplicaciones web. Renovarse o morir…

Enlace a noticia en EstiloHacker.com

ACTUALIZACIÓN (02/09/2008 @ 23:05): El sitio{.postlink} ya está disponible… ¡a bajar!

Debian vs. Ubuntu

Tue, 10 Jun 2008 21:33:04 +0100

¡30 minutos! Eso es exactamente lo que he tardado en instalar Ubuntu con incluso más funcionalidades de las que tenía en mi Debian.

¿Por qué este cambio? Bueno, supongo que la edad tendrá algo que ver y uno ya no tiene tanta paciencia como antes. Y es que en mi humilde opinión, disponer de un sistema Debian con todo correctamente configurado, resulta una tarea tremendamente tediosa, además de que si deseas estar un poco al día con los programas que tienes instalados, te implica estar en una versión testing o unstable de Debian, con el riesgo que ello conlleva.

Concretamente y por poner un ejemplo de lo último que me había ocurrido con mi Debian sid: tenía que asistir a unos talleres de programación, y tuve disponible toda la tarde anterio al día en cuestión, por lo que decidí actualizar el sistema.

Actualizo, y pierdo el driver propietario de NVidia (que lo instalé yo por mi cuenta ya que Debian no lo incluye y Compiz es un gustazo del que no se puede prescindir una vez lo pruebas). Total que lo reinstalo y resulta que la versión de gcc que hay ahora en el sistema es una superior a la que utilicé para compilar el kernel en su día, por lo que no me deja compilar el módulo de nvidia. Solución: recompilar el kernel, y ya de paso, actualizarlo a la última versión disponible, que, casualidades de la vida, da errores de compilación con la versión nueva del gcc. Mi gozo en un pozo.

Opto por downgradear el gcc a la versión que tenía previamente, y además me quedo con la versión que utilizaba hasta el momento del kernel, pero seguía con el problema del módulo nvidia, por lo que vuelvo a intentar compilar el kernel, pero en este caso sin actualizar las fuentes. Compila todo sin problemas ¡uff!

Reinicio, y veo que no tengo conexión inalámbrica. Bueno, no es problema ya que el módulo lo compilo por separado, así que lo hago y lo cargo, pero por lo que sea, no consigo conectar a mi red wifi configurada con WPA (que en su momento ya me costó unas 3 o 4 horas configurar) :'(

Finalmente y tras rehacer toda la configuración que ya hice en su día, consigo volver a conectar. ¡Todo listo y actualizado para el taller!

Pues bien, llego al taller, me dan la configuración para conectar a la red WPA y no lo consigo, que no cunda el pánico… Solución tumbar y levantar la interfaz wifi sucesivas veces (como durante unos 30 minutos) hasta que finalmente consigo IP, todo esto sin tocar configuración sino simplemente repitiendo el proceso una y otra vez. A todo esto, los compañeros de mesa arrancan su Ubuntu, y con un pequeño desplegable seleccionan la red wifi y meten user/password y a trabajar 😮

Sinceramente, situaciones como ésta te hacen plantearte si realmente merece la pena dedicar tantísimo tiempo a la configuración de un ordenador, en detrimento de tiempo de uso. Está claro que no está mal conocer cómo hacer estas cosas a “bajo nivel“, pero llega un punto que resulta excesivo.

En resumen, ahora mismo soy un novato total en Ubuntu, aunque es realmente parecido a Debian, por lo que no creo que me cueste adaptarme (aún así, si tengo en cuenta todo el tiempo ahorrado en configuraciones, por el mero hecho de haber optado por Ubuntu, creo que dispongo de tiempo más que de sobra para adaptarme).

PD: Soy usuario de Debian desde hace aproximadamente 8 años (allá por el 2000 instalé mi primera Potato) y por el momento la voy a mantener en mi servidor, que cariño todavía me queda hacia Debian.

¡Un saludo a todos!

¡Feliz aniversario BASIC!

Fri, 02 May 2008 07:29:36 +0100

El 1 de Mayo de 1964 se ejecutó el primer programa en BASIC. Los creadores de este lenguaje de programación, los profesores John G. Kemeny y Thomas E. Kurtz del Dartmouth College, hace 44 años ejecutaron por primera vez un código escrito en BASIC (Beginner’s All-Purpose Symbolic Instruction Code).

La búsqueda de un lenguaje potente y sencillo de usar (por aquellas fechas se solía utilizar Fortran y Algol) comenzó en el año 1956, con el fin de facilitar a sus estudiantes el aprendizaje de los métodos de programación.

Posteriormente en 1975, Paul Allen y Bill Gates adaptaron este lenguaje a los computadores personales. Como resultado, BASIC fue ampliamente utilizado y evolucionado hasta hoy en día (Visual BASIC .NET).

Personalmente, éste fue el primer lenguaje que utilicé para desarrollar mi primera aplicación medianamente grande, un tablero de parchís (cuando lo miro hoy en día me da hasta vergüenza. no utilicé ni una sola función y todo el código estaba lleno de GOTOs). Para ello utilicé un intérprete de QuickBasic. Qué tiempos aquellos…

¡Felicidades BASIC!

PD: ¿Y tú con qué lenguaje distes tus primeros pasos en el mundo de la programación?

Fuentes:

http://www.wired.com/science/discoveries/news/2008/04/dayintech_0501#

JavaServerFaces, Spring WebFlow y Struts Tiles, todo en uno

Thu, 10 May 2007 11:54:42 +0100

¿Mezclar la versatilidad de JSF con la definición de flujos de negocio de SWF, todo ello con una estética semejante gracias a Tiles? Pues es posible, aunque resulta realmente tedioso y complicado para aquel que es relativamente nuevo a algunas (más bien todas) de estas tecnologías del mundo Java JEE.

A esto es a lo que me he dedicado la última semana de trabajo, a intentar comprender el funcionamiento y buscar por Internet la forma de poder conjugar estas tres tecnologías. He conseguido hacerme una idea del complejo funcionamiento de JSF, SWF me ha sorprendido gratamente por la gran potencia que se consigue con tan pocas líneas de código, y Tiles, aunque ni tan avanzado tecnológicamente ni tan sorprendente, ofrece unas posibilidades de diseño visual que unifica toda la aplicación web con tan solo unos poco ficheros.

Espero poder publicar un tutorial con los pasos a seguir y las aclaraciones necesarias lo antes posible.

Referencias:

¿Por qué sigo con Debian?

Wed, 13 Sep 2006 14:39:17 +0100

La verdad es que ni yo mismo lo sé. Si por lógica fuera, ya haría un tiempo que estaría trabajando con otra distribución más simple y en la que la configuración de los dispositivos no ocupase varios días, realizando cientos de búsquedas por Internet y leyendo varios foros.

Pero la realidad es que aquí sigo, peleando con el apt-get y actualizando contra la versión unstable de esta distribución.

Y tampoco será por falta de alternativas: he probado OpenSuse, Gentoo, Ubuntu, y pese a tener muchas ventajas sobre Debian, les faltaba algo… Puede que sea esa sensación de control y orden, o bien un cariño adquirido durante nuestras largas horas de pelea, pero la verdad es que por más que lo intento no soy capaz de dejarla.

¿Os pasa esto también a vosotros?

El escritorio del futuro

Fri, 23 Jun 2006 12:00:41 +0100

Ésto me lo acabo de encontrar navegando por internet. La verdad es que es muy impresionante:

Se trata de un sistema semejante a un escritorio físico, de los de verdad. Tendremos una especie de mesa con los documentos, los archivos sobre ella. Con el ratón podremos moverlos de un lado a otro de nuestra mesa virtual, y gracias a diversos gestos, podremos agruparlos, apilarlos, ordenarlos, moverlos, y multitud de opciones de la Vida Real, pero con nuestro ordenador y de un modo virtual.

Este escritorio virtual lo está desarrollando BumpTop, y por ahora es un prototipo que tiene muy, muy buena pinta. Estaremos informados acerca de actualizaciones y nuevos lanzamientos, ya que la cosa parece que va a ser más que sobresaliente.

Fuente: http://xataka.com/archivos/2006/06/23-lo-que-sera-el-escritorio-del.php

¿Para cuándo lo tendremos en nuestros Linux? Yo me muero de ganas 😉

Mundo Java

Tue, 30 May 2006 13:58:51 +0100

Desde hace cosa de unas semanas, el mundo Java está cambiando notablemente. Por un lado, Sun publicó Java EE 5.0, junto con Sun Application Server 9.0, primera versión estable del proyecto Glassfish, que pretende implementar un Application Server libre para la especificación de JEE 5. En esta nueva versión se ha incluido, a parte de un cambio de la nomeclatura para las versiones, la especificación de EJB 3.0, Java Persistence API, una mejora en el desarrollo de webservices o JSF entre otras características.

Por otra parte, Sun también anunció en la JavaOne 2006 un cambio de licencia de distribución para el JDK y el JRE (DLJ – Distributor License for Java), a fin de que las distribuciones de Linux que, hasta el momento rechazaban incluirlos en su distribución, cambiaran de parecer, aunque por el momento dicho cambio no está causando los efectos que Sun esperaba. Inicialmente fue RedHat la que mostró sus reticencias, uniéndose posteriormente Debian, la cual sí que incluyó paquetes para Java en un primer momento en sus versión experimental.

Lo que sí parece claro es que por fin Sun está redirigiendo su filosofía y se está orientando más hacia el software libre. Según se comenta, no cabe duda de que Java se convierta en un proyecto libre, la cuestión en estos momentos es cuándo y cómo. Ese momento será seguramente uno de los más importantes, si no el que más, en mucho tiempo de la historia de Java.

Creo que va a ser hora de ponerse en serio con la certificación y volver a los libros, a pesar de la pereza que da el hacerlo. Todo lo bueno requiere un pequeño sacrificio ;).

Hipocresía Total o Semana Santa

Tue, 18 Apr 2006 14:44:10 +0100

Acaba de terminar la semana en el que mucha gente se auto-inflije castigos a fin de contentar o conseguir el favor de la deidad en la que creen. Es curiosa esta tradición y lo mucho que se sigue por los medios de comunicación. Hay gente capaz de hacerse auténticas animaladas, como clavarse unos clavos en pies y manos o flagelarse la espalda (cuanto más sangrienta quede, mayor y mejor es tu fervor religioso).

Luego, a parte de las lesiones auto-inflijidas existe también la costumbre de cargar a cuestas entre varias personas enormes trozos de madera decorado con costosos vestidos y alguna que otra joya, los cuales representan a su dios (o hijo) local y exhibirlos por su barrio, mientras que el resto del vecindario se dedica a cantar a dichos maderos y a llorarles rogando algún favor.

Lo curioso de todo esto es que, si no tengo mal entendido, se supone que el dios cristiano es bondadoso, por lo que no parece muy lógico ofrendarle con el sufrimiento propio. Es más, según creo lo que se debe hacer es tener fe y seguir los mandamientos (aunque algunas de las interpretaciones que da la Iglesia de ellos son un poco más que lastimosos), por lo que parece que crear ídolos de madera costosísimos y arrastrarlos delante de todo un gentío emocionado de ver lo gran creyente que eres no va muy en concordancia con compartir los bienes con los pobres, la humildad y el amor al prójimo (no creo que alguien que sea capaz de hacerse eso, pueda luego ser capaz de tratar medianamente bien a otros).

Aún así, si al menos la gente que hace todo esto fuera de la misma forma durante el resto del año, pues aún tendría un poco más de sentido (que seguiría siendo bastante incomprensible), pero es que la gran mayoría de la gente luego ni se acuerda de lo religioso que demostraron ser la semana santa anterior. Luego no me extraña que la gente llore cuando da la casualidad de que llueve (que falta hace, por otra parte) el día en el que iban a desfilar, teniendo que suspenderlo. Pobrecillos, les tocará esperar otro año para sacar el madero a ventilar.

Pero lo que más me intriga de todo es que si se supone que la Santísima Trinidad son Uno solo, ¿cómo se explica que cada barrio tenga su propio Cristo y/o Virgen y que además el propio sea mejor que el ajeno? Toda una curiosidad religiosa 😉

Magdalena a la valenciana

Sat, 25 Mar 2006 14:07:45 +0100

Parece que alguien ha tenido la original idea de que el mejor final para los sensacionales y espectaculares monumentos que son las gaiatas es… ¡¡¡¡el fuego!!!!

Ahora lo único que queda es que se salve algún ninot 😉

Reencuentro después de 11 años

Wed, 08 Mar 2006 20:51:05 +0100

Ese es el tiempo que hacía que no nos encontrábamos los compañeros de 8º de EGB del colegio Izquierdo. Sí que me había encontrado con alguno de ellos alguna vez, pero no así como anoche, todos juntos recordando las muchas anécdotas que vivimos durante aquellos años.

Conforme me acercaba al punto de encuentro, me iba encontrando más y más nervioso, pensando en quién y cómo encontraría y si los reconocería (11 años es muuuucho tiempo), pero cuando llegué allí pude ver que la mayor parte de compañeros y compañeras que había tenido estaban bastante cambiados, pero la mayor parte eran reconocibles. No acudieron algunos de los que me hubiera gustado volver a ver, pero espero que no pase mucho tiempo hasta que me los encuentre por ahí.

Bueno, tampoco me voy a poner ahora a describir cómo fue la noche. Simplemente quería agradecer a todos los compañeros que siguen ahí a pesar del tiempo y de la distancia su cariño y complicidad.

Una noche genial. Espero que no tardemos otros 11 años en repetirla.

2005 New Year's Eve at London

Tue, 10 Jan 2006 18:12:19 +0100

¡Feliz año 2006!

Un poco tarde, pero por fin he terminado la entrada que quería escribir sobre el viaje de nochevieja a Londres :-D. Es un pequeño resumen de lo que hemos hecho durante el viaje:

Día 1 – 28 Diciembre 2005

Tras levantarnos a las 6 de la mañana, coger el cercanías hasta Valencia, desde allí un autobús hasta Manises, cogiendo un avión hasta Stansted, y finalmente un de nuevo un autobús hasta Liverpool Station nos encontramos con Yolanda que nos muestra el camino hasta la residencia de estudiantes donde íbamos a pasar los siguientes días de estancia (previa caminata de 20 minutos con trastos en la mano y un autobús). A estas alturas María ya había perdido el saco de dormir y la botella de champán que traíamos desde España 🙁

Tras haber comido unos macarrones que nos supieron a gloria, fuimos a ver el centro de la ciudad, pasando por Trafalgar Square y Piccaddilli Circus. Impresionante y bonito. Tras entrar en una tienda de juguetes, cuyo nombre no recuerdo, y probarnos una serie de pelucas y artículos de broma, decidimos volver a la residencia a descansar para poder aprovechar el siguiente día al máximo.

Día 2 – 29 Diciembre 2005

El día del Támesis. Después de haber planeado levantarnos relativamente pronto (a las 9 a.m.), no lo hacemos, por lo que salimos de la residencia rumbo al Tate sobre las 11 a.m. Caminamos hasta el Tower of London, castillo que se encuentra a pocos metros del famoso Tower Bridge, el cual atravesamos, conduciéndonos al linde opuesto del río. Siguiendo el río, encontramos el teatro donde Shakespeare estrenó sus famosas obras, llegando finalmente al Tate. Como bien dijo Cris, «tanta diversión me abruma» 😉

Después de un par de horas observando las obras expuestas en su interior, decidimos ir rollo guiri total a ver el resto de monumentos y sitios típicos de la ciudad que nos de tiempo. Así pues, vamos en dirección Big Ben, que se encuentra al lado de Westminister, y justo en frente de The Eye of London, la noria que construyeron conmemorando el nuevo siglo. La verdad es que fue curioso ver el contraste que se mostraba entre las dos riberas del río.

A estas horas ya estaba anocheciendo, por lo que fuimos hacia el centro de la ciudad para dar una vuelta por las tiendas más rezagadas en el cierre, pasando previamente por Buckingham Palace ****donde pudimos ver los típicos soldados ingleses de guardia en las puertas.

Día 3 – 30 Diciembre 2005

Otro día que casi no vimos el Sol :-s, y es que a las 12:30 no es hora para desayunar. Fue un día de relax, para tomar un poco de fuerzas, visto la que se nos venía encima.

Aún así no lo desaprovechamos del todo ya que a las ocho de la tarde nos fuimos al centro a ver una actuación de Stomp, el grupo de teatro que crea canciones rítmicas con escobas, mecheros, cubos o a base de arrastrar los pies y dar palmas. Sin palabras. Es increíble la cantidad de curro que debe llevar el coordinar todas las personas que actúan para que suene de esa forma. Os lo recomiendo si alguna vez tenéis la opción de ir a verlos.

Una vez terminada la actuación, nos fuimos de vuelta a la residencia para cenar y arreglarnos para nuestra primera noche de fiesta por Londres. Estuvimos en una discoteca que le habían recomendado a Gael, un chico francés que también estaba en la residencia, la cual resultó ser un poco decepcionante: música hardcore, ambiente poco respirable y además un rollo muy raro, ya que te cacheaban antes de entrar y después veías cómo los vigilantes se daban vueltas buscando a quien sea con unas linternas con las que te enfocaban a la cara y te dejaban cegado. Un poco extraño.

Día 4 – 31 Diciembre 2005

Nos levantamos relativamente tarde, por lo que solo dio tiempo a ir a comprar para la cena de esa noche. Una vez llegamos con la compra, nos pusimos manos a la obra y preparamos la cena de nochevieja, que aunque no era muy espectacular, fue la mejor de toda la estancia en Londres (con diferencia!).

Ya durante la cena empezamos con las risas y cuando nos dimos cuenta ya eran las 23:15, demasiado tarde para que llegáramos a tiempo al Big Ben, por lo que decidimos quedarnos allí y seguir con el cachondeo. Se nos fue el santo al cielo y de repente comenzamos a ver fuegos artificiales por la ventana ¡Eran las 0:05! María, en un alarde de inspiración, saca una sartén y una cuchara y comienza a dar las campanadas con los cuartos incluidos. ¡Impresionante!

Una vez se nos pasaron las lágrimas de tanto llorar de la risa, fuimos a prepararnos para salir de fiesta. Esa noche iríamos al pub George donde había una fiesta privada y nos costó convencer a la portero de que nos dejara pasar, pero al final lo conseguimos. En cuanto al local… una rayada: una mezcla entre gótico, punk, popero… y la música HORRIBLE, pero no pasa nada, por que llevábamos una fiesta que con cualquier cosa nos lo habríamos pasado bien.

Día 5 – 1 Enero 2006

El día sin Sol. De este día poco hay que comentar, porque no se hizo prácticamente nada :-S Simplemente dormimos 😎

Bueno, no todo fue dormir :-P. Cuando descansamos nos fuimos a patinar a una pista de patinaje que había a los pies del Tower of London. Cuando terminamos, nos acercamos a Candem, un barrio de Londres muy peculiar y donde encontramos tiendas y puestos de comida muy diversos.

La verdad es que una de las cosas que más llaman la atención de Londres es la diferencia que hay entre los barrios, ya que da la impresión de cambiar de ciudad conforme vas caminando por las calles. Es una sensación muy curiosa.

Día 6 – 2 Enero 2006

Último día completo antes de la vuelta. Éste era nuestro último día que podríamos aprovechar al máximo (también lo era el de María y el de Carol, hasta que decidieron quedarse unos días más :-o). Así que nada más levantarnos fuimos camino de Notting Hill, donde estuvimos paseando un rato y viendo las tiendas. También estuvimos en la librería que sale en la película con el mismo nombre que la zona.

Cuando nos cansamos, fuimos hacia el famoso Hyde Park, un parque gigantesco en pleno corazón de Londres. Allí pudimos ver una estatua dedicada a Peter Pan, un lago lleno de patos y algún que otro gracioso animalillo. Nos acercamos hacia una feria de atracciones que habían instalado donde comimos unos hot dog que nos supieron a gloria.

Para terminar el día (no sin antes pasar por Harrods), nos acercamos a un restaurante hindú, donde pudimos degustar la esquisitez de ese tipo de comida (vamos, asqueroso, por decirlo claro). Después de esto, nos fuimos a dormir.

Día 7 – 3 Enero 2006

El madrugón. Nos levantamos a las 8 de la mañana y nos vamos Cris, Irene y yo a ver el Tower of London, no sea cosa que les fuera a dar algo a las pobres chiquillas 😛 La verdad es que no esperaba mucho de él, y el coste de la entrada me parecía un poco alto, pero tras haber entrado, me fui con la sensación de que me faltaba tiempo para verlo todo, y eso que estuvimos desde las 10:30 hasta las 14:00.

Nos volvimos a la residencia, cogimos las maletas y nos fuimos a Liverpool Station a coger un autobús que nos llevara a Stansted para coger el avión de vuelta. Sinceramente todavía no sé cómo llegamos a cogerlo, porque yo estaba convencido de que no llegabamos.

Finalmente, y sin problema alguno (salvo algunas turbulencias), llegamos a Manises, donde nada más bajar nos dieron la bienvenida «a la española», pero esto casi que lo dejo para otra entrada en weblog 😉

Estoy seguro de que me dejo cosas, pero ya me ha quedado un poco largo el post 😛 Si queréis ver más cosas sobre Londres, aquí os dejo el álbum de fotos del viaje.

Resumiendo, ha sido un viaje que no olvidaré nunca, y en el que me lo he pasado genial. ¡Qué campanadas más espectaculares!

Web 2.0

Wed, 14 Dec 2005 09:37:39 +0100

Es el término de moda en los entornos de programación web: AJAX, consistente en la interacción de las tecnologías JavaScript, HTML/CSS y XML. Aunque en sí misma esta conjunción resulta bastante reciente, las tecnologías implicadas son ya viejas glorias entre los programadores.

El concepto básico en el que se basa esta técnica de programación es bastante simple: cuando se produce un evento en el navegador web que está mostrando el código HTML, en vez de realizar una petición HTTP al servidor, tal y como se suele realizar normalmente, se crea un objeto JavaScript XMLHttpRequest, encargado de realizar dicha petición, la cual devolverá unos datos que serán pasados al manejador del evento que se haya definido.

Sencillo ¿verdad?. La gracia del tema (puesto que hasta ahora lo único que se ha hecho es complicar lo que antes se hacía de forma sencilla) es que la petición HTTP y la ejecución del manejador del evento se realizan en un segundo plano y de forma asíncrona, de forma que el efecto producido por el evento es percibido por el usuario sólo cuando la comunicación con el servidor ya ha terminado. Además, no resulta necesario realizar una recarga del código HTML, ya que es el propio manejador javascript el que edita el árbol DOM de la página web, lo que a efectos de interfaz resulta en una web dinámica que responde a eventos sin repetidas esperas entre cargas de páginas.

Una vez visto en qué consiste esta técnica, es momento de ver algunas de las killer app actuales que utilizan AJAX:

Gmail: Sin lugar a dudas es la aplicación que lanzó a la fama AJAX, asombrando con la navegación entre emails sin necesidad de hacer recargas, o del autocompletado a la hora de escribir una dirección de email o de la corrección de sintaxis en la edición.
Google Maps: Otra aplicación de Google que permite navegar por el mundo a través de un mapa capaz de superponer fotos satélite.
Flickr!: Perteneciente a Yahoo!, ofrece la posibilidad de organizar y etiquetar nuestras fotos preferidas, a través de una interfaz Flash y técnicas AJAX.
Meebo: Cliente de mensajería instántanea via web, con capacidad para hacer login en la red de IM que se prefiera. Personalmente, la simulación de ventanas de chat que tiene me parece que es realmente impresionante.
Writely: Editor de textos WYSIWYG que permite guardar los documentos en formato word, además de una organización por etiquetas.

Por el momento el punto más flojo de la cuestión es idear qué nuevas funcionalidades pueden sacar un mayor partido a esta reciente técnica, por lo que a pensar se ha dicho ;-).

Y tú, ¿ya has programado una aplicación web utilizando AJAX?

Google ofrece IM/Jabber

Wed, 24 Aug 2005 07:54:30 +0100

Pues parece ser que los tan sonados rumores de que Google iba a ofrecer un servicio de mensajería instántanea se han hecho realidad. Es más, también se ha confirmado que utiliza el protocolo Jabber, lo cual supondrá un fuerte empujón a esta tecnología libre. El nombre con el que se ha bautizado este servicio es Google Talk.

Podemos ver que ofrecen un cliente, por el momento únicamente para sistemas Windows, con el cual podremos realizar tanto conversaciones vía texto o vía voz.

El único inconveniente es que por el momento sólo aquéllos que dispongan de una cuenta de correo GMail podrán probar el nuevo sistema de IM.

Podemos seguir los comentarios que se realicen en Barrapunto y en Slashdot.

¿Alcohol = Diversión?

Tue, 12 Apr 2005 20:46:44 +0100

El Sábado por la noche, camino de vuelta a casa sobre las 6 de la mañana, después de una noche de fiesta con los amigos, pasaba por delante de la biblioteca de Rafalafena, desde donde se podía observar el cielo totalmente despejado (cosa bastante normal en las noches con viento, como fue ésta), teniendo una visión impresionante de la constelación Cassiopea justo encima del edificio de la biblioteca. No sé muy bien por qué, pero esa situación activó el «modo meditación» durante el resto del camino, lo que me hizo pensar en un concepto que se suele dar por supuesto y es el asociar el alcohol con la diversión.

Lo curioso del tema no es que el beber alcohol implique diversión (que si se controla bien, en la mayoría de los casos suele ser así) sino la dependencia e incredulidad que se genera en el «bebedor festero habitual».

Me explico:

Por un lado, se es incapaz de salir sin haber hecho un botellón previo o haberte gastado una pasta en algún que otro bareto, ya que de ser así, la noche va promete ser un coñazo de cuidado. Resulta intrigante ver a dos personas sin haber bebido una gota de alcohol, vacilándose mutuamente por la calle, diciendo que hasta que no se hagan 5 litros entre los dos, no se mueven del bar. ¿Por qué? La respuesta que obtuve en una ocasión fue que parece ser que cuánto más se bebe, menos probabilidades de que te acuerdes a la mañana siguiente de lo que hiciste (lo cual me llevó a pensar que tal vez fuera poco recomendable estar cerca de quien me lo dijo). Pensando concienzudamente en esta respuesta tan … respuesta, me pareció una actitud aún más rídicula, pero eso ya es cuestión personal de cada uno.
Por otro lado, no es posible comprender cómo puede haber gente que no beba y se lo pase bien. Es más, se da por supuesto la implicación biyectiva entre no beber y muermo. De hecho es pecado mortal decir que no bebes alcohol por no hablar de las nefastas implicaciones político-religioso-social-festeras que conlleva pedir un botellín de agua en la discoteca (no hace falta hablar sobre las realmente preocupantes consecuencias presupuestarias que de hecho conlleva el infame acto).

Y por mucho que pueda resultar extraño, esto es así, o por lo menos es lo que me ha tocado sufrir en más de una ocasión. De hecho, no han sido pocas las veces que me presentan a alguien y me pregunta que si me pasa algo cuando pedimos bebida en la barra. ¿No resulta un poco fuerte el hecho de que se dé este nivel de aceptación del alcohol e incluso la sorpresa producida por el hecho de no consumirlo? Supongo que la mejor respuesta a esta pregunta se puede encontrar en el refranero: Cree el ladrón que todos son de su condición.

Supongo que en este punto es normal suponer que soy un abscemio total, y el caso es que cuando salgo me suelo tomar algo cuando salgo por ahí, poca cosa, pero es que realmente no siento la necesidad social de que llegue el Lunes y mis compañeros me pregunten por el fin de semana y no les pueda contestar que me pillé un ciego increíble (de hecho tampoco acabo de entender qué mérito tiene gastarse más de 30 € en bebida para luego no saber qué es exactamente lo que hiciste, se ve que es cuestión de aguante, ya que no todo el mundo es capaz de hacerlo, y, por lo que se ve, eso está bien valorado).

En fin, el camino de vuelta no dio para mucho más, y como sólo era el «modo filosófico» pues no pude encontrar alguna respuesta razonable al tema, sino que solo encontraba más situaciones éticamente pobres en relación con el alcohol. Simplemente me gustaría sugerir que se hiciese la sencilla prueba ante alguien que no te conoce de decir que no sueles beber cuando sales, resulta realmente curioso ver la cara extraño que se le queda a quien lo escucha. Si alguien lo hace, que no dude en postearlo.

¿Y tú, bebes para pasártelo bien o simplemente bebes lo que te apetece cuando te lo pasas bien?

Magdalena Vítol y sus daños colaterales

Mon, 07 Mar 2005 00:17:01 +0100

Al final todo lo bueno llega a su fin, y las fiestas de la Magdalena no han sido una excepción. Tras 10 días de frío y sufrimiento por pasarlo bien, volvemos a la rutinaria vida del trabajo diario. En general han estado bastante bien, aunque como siempre, he acabado bastante “quemado” con la organización y lo elitistas que pueden llegar a ser, pero bueno, prefiero no escribir sobre ello, no creo que ni tan siquiera lo merezcan.

Aunque lo que sí que voy a denunciar es la fatal organización que hubo durante el acto de la Magdalena Vítol, el cual tras retrasarse durante casi tres cuartos de hora, se extendió casi una hora más, gracias a una pobre actuación teatral, en la cual no se tuvo en cuenta el estado meteorológico (que no es que acompañara mucho) y que casí hace acabar a una actriz que estaba colgada en un globo-luna, acabar en la punta del Fadrí. Pero lo peor estaba aún por llegar cuando a los organizadores les dio por lanzar un mini-castillo de fuegos artificiales hacia el público lo que produjo la consecuente avalancha de gente y sus correspondientes heridos y daños colaterales. Además, y para más inri, una carcasa cayó justo al lado de donde estabamos nosotros, causando una escena un tanto dantesca. Las consecuencias, pues mi amigo Héctor con una ampolla en el cuello, Guillermo oliendo a pollo quemado y yo con un par de quemones en la chaqueta. El resto de gente que venía con nosotros creo que salió más o menos intactos, salvo por el mal rato pasado.

Creo y espero que será dificil de mejorar en próximos años, aunque si hay algo que no deja de sorprenderme año tras año son los organizadores y sus geniales ideas festivas. A ver con que nos premian en el 2006.

Sospechas conspiracionistas

Thu, 13 Jan 2005 22:46:56 +0100

Hoy he podido escuchar y ver en diversos medios de comunicación el anuncio de que la NASA realizaba el lanzamiento de su última misión espacial, Deep Impact, que transportará una nave cuya misión será estreyarse con el cometa Tempel 1 a una velocidad de nada menos que 37.000 km/h. El aplastante suceso ocurrirá el 4 de Julio del presente año, a una distancia 431 millones de kilómetros, un poco lejos para que cierto país pueda usar la explosión como si de fuegos artificiales se tratasen para celebrar la fiesta nacional que acontece el mismo día.

Según la NASA, esta misión despierta el interés científico ya que se supone que el cometa está compuesto por los materiales primigéneos que formaban el sistema solar, por lo que se desvelarían muchos secretos aún por descubrir. Si a esto le añadimos que no se sabe si el cometa quedará totalmente destruido a causa del impacto, o si únicamente se creará un pequeño cráter del tamaño de un campo de fútbol y de unos 10 pisos de altura, obtenemos lo que puede ser una de las experiencias científico-espaciales más populares del año que comienza.

La inquietud surge cuando uno comienza a darle vueltas a unas cuantas ideas …

Una misión de este tipo debe ser, y realmente lo es, un poco cara de subvencionar, por lo que para que haya sido agraciada con tal cantidad de dinero, debe ser debidamente justificado el por qué es necesario realizar dicha inversión. Así pues, si yo fuera el inversor, y vinieran una serie de científicos a pedirme dinero para estrellar una nave contra un cometa para descubrir de qué esta compuesto, pero que cabe la posibilidad de que al chocar nos carguemos al susodicho cometa y que, por lo tanto, no se pueda realizar el estudio, pues como que tendría muy claro lo que tendría que hacer: Señores, estrellen sus vehículos contra la Casa Blanca para intentar descubrir lo que hay dentro de ella (por ejemplo).

Ahora hablando en serio, huele un poco raro que se le dé tanto revuelo a una misión tan «pobre» como la Deep Impact. Además curioso nombre el asignado, referente a una película en la que un cometa se estrella contra la Tierra. Parece como si hubieran querido acallar las posibles ideas catastróficas ironizando precisamente sobre ellas. Y es que, a mi parecer, la NASA ha puesto dicho nombre a la misión, por no poner el nombre de la otra película de cometas protagonizada por Bruce Willis, Armageddon, con lo que más que apaciguar a las masas, lo que haría sería cundir el pánico por la posible asociación de objetivos entre la misión y la película mencionada, es decir, el destruir o desviar un cometa en dirección hacia la Tierra.

Por otro lado, me consuela (o al menos eso el lo que deseo), pensar que existen diversos laboratorios independientes de la NASA que podrían realizar los cálculos para descartar o confirmar el posible destino terrestre del cometa Tempel 1, por lo que, en caso de que nos fuera ha realizar una visita demasiado cercana, supongo que se correría la voz como si de una mecha se tratase.

Bueno, pues como toda buena teoría conspiracionista, no se puede ni afirmar ni desmentir que lo dicho sea así, ya que tan lógico es pensar lo uno como lo otro. Así que cada cual saque sus propias conclusiones.

Fin de Año en Benidorm

Tue, 04 Jan 2005 22:33:20 +0100

¡Feliz año 2005 a todo el mundo!

Hoy mismo he llegado de pasar este mini-puente de fin de año en Benidorm con los colegas de Benicassim. La verdad es que no ha estado nada mal el fin de semana, a pesar de haber trabajado hasta instantes antes de coger el coche, aunque hubiera sido mejor ir un poco más descansado y salir un poco más tarde el Domingo, ya que tuvimos que dejar las habitaciones sobre las 10 de la mañana, por lo que el Sábado tuve que acostarme no muy tarde para poder conducir en condiciones a la mañana siguiente (mejor no arriesgar con el coche).

En total éramos 8 personas: Rafa, César, Alejandro, Julen, Natalia, Noelia, Carlos (que vino un día más tarde y se fue uno antes con Noelia) y yo, repartidos en dos habitaciones de 4 (Rafa, César, Alejandro y Carlos en una y Julen, Natalia, Noelia y yo en la otra). La verdad es que el hotel estaba muy bien para el precio que nos dieron, ya que el viaje al final me ha salido por unos 90 € aproximadamente, incluidos estancia, entrada a las discotecas Penélope, KM y Hacienda (antes Pachá), comida y gasolina. Muy bien de precio, sin lugar a dudas.

En cuanto al ambiente, sencillamente genial. Sólo vi una ambulancia en toda la noche y no se vio ninguna bronca en ninguna de las discotecas, cosa realmente extraña. La gente por lo general te felicitaba el año, aunque probablemente fuera por lo pedo que iban.

En cuanto a las tías, pues para variar, poca cosa, aunque tampoco estuvo mal del todo. Pero, eso sí, cachondeo mogollón.

Inicio astrofotográfico

Wed, 09 Jun 2004 09:16:26 +0100

Ya llevaba tiempo tratando de empezar con la astrofotografía con webcam, pero entre unas cosas y otras siempre lo dejaba para otro momento. Al final el pasado día 6 de Junio me decidí a intentarlo.

Tras unos cuantos intentos por usar un adaptado hecho con la funda de un carrete de fotos, acabé sujetando la webcam al portaocular con una simple goma que me dieron mis abuelos la última vez que estuve en Madrid (¡hay que ver lo que a uno le puede hacer falta en algunos momentos!), lo cual, aunque no es una forma muy ortodoxa, dio buenos resultados, como se puede ver en la foto anterior.

Entre Alfredo y yo hicimos unas cuantas tomas de Jupiter con sus lunas (por primera vez pude apreciar las bandas de este planeta), así como otras cuantas de la Luna, pero dado a mi alto nivel de novatez, no caí en la cuenta de que cada vez que grababa un vídeo, estaba borrando el anterior, ya que se usaba el mismo archivo. Aún así conseguimos una foto de la que me siento muy orgulloso, ya que fue la foto que me inició formalmente en el mundo de la astrofotografía con webcam.

Mono: ¡Hola Mundo!

Mon, 29 Mar 2004 13:07:46 +0100

Para retomar de nuevo la marcha del blog, he decidido comenzar mostrando algunos ejemplos de programación en C#. Por el momento os dejo el obligatorio programa para todo aquel que empieza con algún lenguaje.

Hola Mundo!

using System;

namespace HolaMundo {

   public class HolaMundo {
      public static void Main (string [] args) {
         Console.WriteLine ("Hola Mundo!");
      }
   }
}

Sencillo, ¿verdad? Tiene mucha semejanza con Java, exceptuando que las palabras reservadas difieren y que Java no posee el concepto de espacios con nombre o NameSpaces, entre otras.

Bueno, prometo que el próximo ejemplo será más interesante que éste.

Funcionamiento de .NET

Fri, 08 Aug 2003 09:27:59 +0100

En los artículos anteriores hemos hablado de conceptos como CTS, CLI (CLS), IL o JIT, los cuales pueden resultar bastante confusos. A continuación daremos una aclaración del significado de cada uno de ellos, y explicaremos su función dentro de la plataforma .NET, para lo cual se hará una explicación más a fondo de su funcionamiento.

Hemos comentado en artículos anteriores que cuando compilas un código fuente a un binario de .NET, éste binario no contiene código máquina de la arquitectura en la que se compiló, sino que se genera un código para una máquina virtual, al estilo del bytecode de Java.

Además se comentó que era posible utilizar un objeto escrito en un lenguaje .NET desde otro lenguaje .NET. La explicación a ésto es un poco más compleja: cuando tú compilas un código, se genera un Assembly o ensamblaje, que es la unidad mínima de compilación en .NET (que además es autosuficiente y autodescriptiva), el cual puede contenerse en un fihcero .exe o .dll, dependiendo del tipo de código que contenga y de la función a realizar. Dicho assembly está formado por un código que entenderá la máquina virtual, llamado IL o Interpreted Language, y es lo que denominaremos CLI o Common Language Interface, que, junto con el uso exclusivo de los tipos definidos en el CTS o Common Type System, permitirán que cualquier compilador .NET pueda entender dicho assembly al generar otros programas o librerías.

Hasta este momento hemos conseguido unificar el lenguaje pseudo-ensamblador que usarán los compiladores .NET, de forma que será posible la interacción entre distintos lenguajes. Pero, ¿cómo se resuelve el problema de que distintas arquitecturas y sistemas operativos puedan ejecutar un mismo código máquina?. Pues la respuesta es parecida a la que da Java. Java implementa una máquina virtual que interpreta el bytecode. .NET hace una precompilación del IL para proceder a su ejecución. A esta técnica se le denomina JIT Compilation o Just In Time Compilation. ¿Ventajas? Pues como la compilación resulta que se reduce practicamente una traducción entre lenguajes máquina, ésta requiere muy poco tiempo, por lo que el resultado final es que es más eficiente que la interpretación del código (de todas formas Mono también dispone de un intérprete de IL, llamado mint)

Como comentario final al artículo, decir que me resultó realmente extraño que Microsoft diseñara una plataforma que fuera capaz de de correr en diferentes arquitecturas y más aún, en diferentes sistemas operativos. La explicación es que Microsoft no buscaba la portabilidad, sino que buscaba la integración de distintos lenguajes de programación (C#, C++.NET, VisualBasic.NET, etc), consiguiendo como «daño colateral» dicha portabilidad.

Pues eso ha sido todo por el momento. Nos vemos en los próximos artículos.

Pasado, presente y futuro de Mono

Thu, 31 Jul 2003 11:42:19 +0100

En este artículo os comentaré un poco de historia sobre la evolución de la tecnología .NET y del proyecto Mono, que a pesar de su corta existencia, ha sido un proyecto muy vivo, y en el cual han participado y participan muchas personas de todo el mundo.

.NET es una tecnología desarrollada por Microsoft, que ha sido estandarizada en el ECMA (C#, CLI), ofreciendo la posibilidad de crear utilidades que trabajen con este entorno, sin miedo a que un día Microsoft interponga una demanda o que simplemente cambie las especificaciones a su antojo.

Así pues, Ximian Inc., empresa dirigida por Miguel de Icaza, decidió el 9 de Julio de 2001 crear un runtime y un compilador para la plataforma .NET en sistemas Unix. Dicho entorno fue bautizado como Mono.

Las utilidades del proyecto (runtime = mono; compilador de C# = mcs) están escritos en C#, el lenguaje estrella de la plataforma .NET, por lo que su desarrollo inicial se realizó en el entorno .NET de Microsoft, hasta que el 3 de Enero de 2002 se anunció que el proyecto era auto-suficiente, es decir, que era capaz de compilarse y ejecutarse a sí mismo, con lo cual ya no fue necesario el uso del compilador de Microsoft (csc), pudiendo continuar el desarrollo usando el propio proyecto.

Desde entonces el desarrollo del proyecto ha estado centrado en el desarrollo de la librería estándar, el desarrollo de compiladores para otros lenguajes, como por ejemplo VisualBasic (mbas), la adaptación del sistema de interfaz de usuario de windows (System.Windows.Forms o SWF) al resto de sistemas operativos, usando para ello las librerías del proyecto Wine (http://www.winehq.com), y el desarrollo de ASP.NET y los servicios web, habiendo desarrollado un mini servidor web (xsp) para su uso en entorno .NET (aunque también existe un módulo para Apache llamado mod_mono).

El futuro immediato de Mono está orientado a completar y depurar la librería estándar, sin perder de vista las nuevas características incluidas en la nueva estandarización del entorno, .NET 1.1 (C# 2.0), en donde se incluyen, entre otras cosas, la implementación de genéricos en C#.

Éstos han sido los pasos, a grandes rasgos, de lo sucedido en torno al proyecto. Para obtener más información, remitiros a las archivos de las listas de correos que podreis encontrar en la web del proyecto.

En el siguiente artículo os haré una breve descripción de las principales utilidades de Mono, así como un pequeño glosario de los acrónimos más utilizados en relación con .NET.

¿Qué es Mono?

Wed, 30 Jul 2003 13:30:31 +0100

Mono (http://www.go-mono.com) es la implementación libre de la tecnología .NET, capaz de correr en Linux, sistemas *NIX, MacOS, y Windows. Gracias a este proyecto, los usuarios de sistemas *NIX podremos contar con los últimos avances en lo que a tecnología del software se refiere.

Y es que Mono no es simplemente un compilador y su correspondiente runtime, sino que también se incluyen una serie de utilidades que nos facilitarán mucho la vida a la hora de programar, como un explorador de documentación –MonoDoc-, o un mini servidor web –XSP-, con capacidad de procesar programas escritos para ASP.NET o de ofrecer un servicio web para el resto de Internet, entre otras.

Además con Mono no estás limitado a un solo lenguaje, sino que puedes programar la parte que más te interese de un proyecto en un determinado lenguaje, programando el resto de éste en otro, facilitando con ello el diseño de rutinas que podrían ser más fáciles de implementar en otros lenguajes. Por el momento puedes programar en C# y VisualBasic.NET, aunque ya se están desarrollando compiladores para otros lenguajes, como puede ser Python o Ruby.

Esta homogeneidad en los lenguajes se consigue gracias a que un programa escrito para Mono o .NET no se compila directamente a código máquina, sino que es compilado a IL, un lenguaje ensamblador de alto nivel, el cual es traducido por el runtime (JIT) en el momento de la ejecución, realizando las optimizaciones que sean oportunas según el tipo de arquitectura en el que se esté ejecutando el runtime. Este IL tiene sus propia estructura (CLS) y sus propias estructuras de datos (CTS), de forma que los diferentes tipos de datos de los lenguajes .NET, deben ser mapeados a tipos de datos del CTS. Además, y como consecuencia directa de lo anterior, podemos conseguir portabilidad entre arquitecturas y entre sistemas operativos, únicamente con tener en cuenta que no se deben realizar tareas específicas para un determinado entorno (como lecturas de registro, carga de librerías que no estén portadas a otros sistemas, etc.).

La verdad es que es que aunque es una tecnología que está dando sus primeros pasos, promete ser muy interesante. Y es por ello que, a partir de ahora, me dedicaré a contaros lo que me sea posible en este blog. De momento os recomiendo que os bajeis las fuentes de la página web, lo compileis, y echeis un vistazo a los ejemplos que se incluyen.