Diagrams as Code

I imagine that everyone reading this blog should be, by now, familiar with the term Infrastructure as Code (IaC). If not because we have written a few articles on this blog, probably because it is a widely extended-term nowadays.

At the same time I assume familiarity with the IaC term, I have not heard a lot of people talking about a similar concept called Diagram as Code (DaC) but focus on diagrams. I am someone that, when I arrive at a new environment, finds diagrams very useful to have a general view of how a new system works or, when given explanations to a new joiner. But, at the same time, I must recognise, sometimes, I am not diligent enough to update them or, even worst, I arrived at projects where, or they are too old to make sense or there are none.

The reasons for that can be various, it can be hard for developers to maintain diagrams, lack of time, lack of knowledge on the system, not obvious location of the editable file, only obsolete diagrams available and so on.

I have been playing lately with the DaC concept and, with a little bit of effort, all new practices require some level of it till they are part of the workflow, it can fill this gap and help developers and, other profiles in general, to keep diagrams up to date.

In addition, there are some extra benefits of using these tools such as easy version control, the need for only a text editor to modify the diagram and, the ability to generate the diagrams everywhere, even, as part of our pipelines.

This article is going to cover some of the tools I have found and play with it lately, the goal is to have a brief introduction to the tools, be familiar with their capabilities and restrictions and, try to figure out if they can be introduced on our production environments as a long term practise. And, why not, compare which tool offers the most eye-catching ones, in the end, people are going to pay more attention to these ones.

Just a quick note before we start, all the tools we are going to see are open source tools and freely available. I am not going to explore any payment tool and, I am not involved in any way in the tools we are going to be using.

Graphviz

The first tool, actually a library, we are going to see is Graphviz. In advance, I am going to say, we are not exploring this option in depth because it is too low level for my taste or the purpose we are trying to achieve. It is a great solution if you want to generate diagrams as part of your applications. In fact, some of the higher-level solution we are going to explore use this library to be able to generate the diagrams. With that said, they define themselves as:

Graphviz is open source graph visualization software. Graph visualization is a way of representing structural information as diagrams of abstract graphs and networks. It has important applications in networking, bioinformatics, software engineering, database and web design, machine learning, and in visual interfaces for other technical domains.

The Graphviz layout programs take descriptions of graphs in a simple text language, and make diagrams in useful formats, such as images and SVG for web pages; PDF or Postscript for inclusion in other documents; or display in an interactive graph browser. Graphviz has many useful features for concrete diagrams, such as options for colors, fonts, tabular node layouts, line styles, hyperlinks, and custom shapes.

https://graphviz.org

The installation process in an Ubuntu machine is quite simple using the package manager:

sudo apt install graphviz

As I have said before, we are not going to explore deeper this library, we can check on the documentation for some examples built in C and, the use of the command line tools it offers but, for my taste, it is a too low-level solution to directly use it when implementing DaC practises.

PlantUML

The next tool is PlantUML. Regardless of what the name seems to imply, the tool is able to generate multiple types of diagrams, all of them listed on their web page. Some examples are:

The diagrams are defined using a simple and intuitive language and, images can be generated in PNG, SVG or, LaTeX format.

They provide an online tool it can be used for evaluation and testing purposes but, in this case, we are going to be installing it locally, especially to test how hard it is and how integrable is in our CI/CD pipelines as part of our evaluation. By the way, this is one of the tools it uses Graphviz behind the scenes.

There is no installation process, the tool just needs the download of the corresponding JAR file from their download page.

Now, let’s use it. We are going to generate a State Diagram. It is just one of the examples we can find on the tool’s page. The code used to generate the example diagram is the one that follows and is going to be stored in a TXT file:

@startuml
scale 600 width

[*] -> State1
State1 --> State2 : Succeeded
State1 --> [*] : Aborted
State2 --> State3 : Succeeded
State2 --> [*] : Aborted
state State3 {
  state "Accumulate Enough Data\nLong State Name" as long1
  long1 : Just a test
  [*] --> long1
  long1 --> long1 : New Data
  long1 --> ProcessData : Enough Data
}
State3 --> State3 : Failed
State3 --> [*] : Succeeded / Save Result
State3 --> [*] : Aborted

@enduml

Now, let’s generate the diagram:

java -jar ~/tools/plantuml.jar plantuml-state.txt

The result is going to be something like:

State Diagram generated with PlantUML

As we can see, the result is pretty good, especially if we consider that it has taken us around five minutes to write the code without knowing the syntax and we have not had to deal with positioning the element on a drag and drop screen.

Taking a look at the examples, the diagrams are not particularly beautiful but, the easy use of the tool and the variety of diagrams supported makes this tool a good candidate for further exploration.

WebSequenceDiagrams

WebSequenceDiagrams is just a web page that allows us to create in a quick and simple way Sequence Diagrams. It has some advantages such as offering multiple colours, there is no need to install anything and, having only one purpose, it covers it quite well in a simple way.

We are not going to explore this option further because it does not cover our needs, we want more variety of diagrams and, it does not seem integrable on our daily routines and CI/CD pipelines.

Asciidoctor Diagram

I assume everyone is more or less aware of the existence of the Asciidoctor project. The project is a fast, open-source text processor and publishing toolchain for converting AsciiDoc content to HTML5, DocBook, PDF, and other formats.

Asccidoctor Diagram is a set of Asciidoctor extensions that enable you to add diagrams, which you describe using plain text, to your AsciiDoc document.

The installation of the extension is quite simple, just a basic RubyGem that can be installed following the standard way.

gem install asciidoctor-diagram

There are other options of usage but, we are going to do an example using the terminal and, using the PlantUML syntax we have already seen.

[plantuml, Asciidoctor-classes, png]     
....
class BlockProcessor
class DiagramBlock
class DitaaBlock
class PlantUmlBlock

BlockProcessor <|-- DiagramBlock
DiagramBlock <|-- DitaaBlock
DiagramBlock <|-- PlantUmlBlock
....

The result been something like:

Generated with Asciidoctor Diagrams extension

One of the advantages of this tool is that it supports multiple diagram types. As we can see, we have used the PlantUML syntax but, there are many more available. Check the documentation.

Another of the advantages is it is based on Asciidoctor that is a very well known tool and, in addition to the image it generates an HTML page with extra content if desired. Seems worth it for further exploration.

Structurizr

I was going to skip this one because, despite having a free option, requires some subscription for determinate features and, besides, it does not seem as easy to integrate and use as other tools we are seeing.

Despite all of this, I thought it was worth it to mention it due to the demo page they offer where, with just some clicking, you can see the diagram expressed on different syntaxes such as PlantUML or WebSequenceDiagrams.

Diagrams

Diagrams is a tool that seems to have been implemented explicitly to follow the Diagram as Code practice focus on infrastructure. It allows you to write diagrams using Python and, in addition to support and having nice images for the main cloud providers, it allows you to fetch non-available images to use them in your diagrams.

Installation can be done using any of the available common mechanism in Python, in our case, pip3.

pip3 install diagrams

This is another one of the tools that, behind the scenes, uses Graphviz to do its job.

Let’s create our diagram now:

from diagrams import Cluster, Diagram
from diagrams.onprem.analytics import Spark
from diagrams.onprem.compute import Server
from diagrams.onprem.database import PostgreSQL
from diagrams.onprem.inmemory import Redis
from diagrams.onprem.aggregator import Fluentd
from diagrams.onprem.monitoring import Grafana, Prometheus
from diagrams.onprem.network import Nginx
from diagrams.onprem.queue import Kafka

with Diagram("Advanced Web Service with On-Premise", show=False):
    ingress = Nginx("ingress")

    metrics = Prometheus("metric")
    metrics << Grafana("monitoring")

    with Cluster("Service Cluster"):
        grpcsvc = [
            Server("grpc1"),
            Server("grpc2"),
            Server("grpc3")]

    with Cluster("Sessions HA"):
        master = Redis("session")
        master - Redis("replica") << metrics
        grpcsvc >> master

    with Cluster("Database HA"):
        master = PostgreSQL("users")
        master - PostgreSQL("slave") << metrics
        grpcsvc >> master

    aggregator = Fluentd("logging")
    aggregator >> Kafka("stream") >> Spark("analytics")

    ingress >> grpcsvc >> aggregator

And, let’s generate the diagram:

python3 diagrams-web-service.py

With that, the result is something like:

Diagram generated with Diagrams

As we can see, it is easy to understand and, the best part, it is quite eye-catching. And, everything looks in place without the need to mess with a drag and drop tool to position our elements.

Conclusion

As always, we need to evaluate which tool is the one that best fit our use case but, after seeing a few of them, my conclusions are:

  • If I need to generate infrastructure diagrams I will go with the Diagrams tools. Seems very easy to use been based on Python and, the results are very visually appealing.
  • For any other type of diagram, I will be inclined to use PlantUML. It seems to support a big deal of diagram types and, despite not being the most beautiful ones, it seems the results can be clear and useful enough.

Asciidoctor Diagrams seems a good option if your team or organisation is already using Asciidoctor and, it seems a good option if we want something else than just a diagram generated.

Diagrams as Code

Defining Software Architecture

The Software Architecture definition is something that, for a long time, the industry as a whole has not been able to agree or to find a consensual definition. In some cases, it is defined as the blueprint of a system and, in other, it is the roadmap for developing a system, including all the options in the middle.

The truth is that it is both things and, probably, much more than that. To try to figure out what it is, I think we are still far from a formal definition, we can focus on what it is analysed when we take a look at concrete architectures.

  • Structure
  • Architecture characteristics
  • Architecture decisions
  • Design principles

Structure

When we talk about the structure we are referring to the type or types of architecture styles selected to implement a system such as microservices, layered, or a microkernel. These styles do not describe and architecture but its structure.

Architecture characteristics

The architecture characteristics define the quality attributes of a system, the “-ilities” the system must support. These characteristics are not related to the business functionality of the system but with its proper function. They are sometimes known as non-functional requirements. Some of them are:

AvailabilityReliabilityTestability
ScalabilitySecurityAgility
Fault ToleranceElasticityRecoverability
PerformanceDeployabilityLearnability
Architecture characteristics

A long list of them, maybe too long, can be found on one of the articles on the Wikipedia: List of system quality attributes.

Architecture decisions

Architecture decisions define the rules of how a system should be built. Architecture decisions form the constraints of a system and inform the development teams of what it is allowed and what it is not when building the system.

An example, it is the decision of who should have access to the databases on the system, deciding that only business and service layers can access them and excluding the presentation layer.

When some of these decisions need to be broken due to constraints at one part of the system, this can be done using a variance.

Design principles

Design principles are guidelines rather than strong rules to follow. Things like synchronous versus asynchronous communications within a microservices architecture. It is some kind of a preferred way to do it but this does not mean developers cannot take different approaches on concrete situations.

Reference: “Fundamentals of Software Architecture by Mark Richards and Neal Ford (O’Reilly). Copyright 2020 Mark Richards, Neal Ford, 978-1-492-04345-4″

Defining Software Architecture

Git branch on terminal prompt

There are a lot of GUI tools to interact with git these days but, a lot of us, we are still using the terminal for that. One thing I have found very useful is, once you are in a folder with a git repository, to be able to see the branch in use on the terminal prompt. We can achieve this with a few steps.

Step 1

Let’s check the actual definition of our prompt. Mine looks something like:

echo $PS1
\[\e]0;\u@\h: \w\a\]\[\033[01;32m\]\u@\h\[\033[00m\]:\[\033[01;34m\]\w\[\033[00m\]$

Step 2

Open with our favourite the file ‘~/.bashrc. In my case, ‘Vim’.

Step 3

Let’s create a small function to figure out the branch we are once we are on a folder with a git repository.

git_branch() {
  git branch 2> /dev/null | sed -e '/^[^*]/d' -e 's/* \(.*\)/(\1)/'
}

Step 4

Let’s redefine the variable ‘PS1’ to include the function we have just defined. In addition, let’s add some colour to the branch name to be able to see it easily. Taking my initial values and adding the function call the result should be something like:

export PS1="\[\e]0;\u@\h: \w\a\]${debian_chroot:+($debian_chroot)}\[\033[01;32m\]\u@\h\[\033[00m\]:\[\033[01;34m\]\w\[\033[00m\] \[\033[00;32m\]\$(git_branch)\[\033[00m\]\$ "

And, it should look like:

Git branch on terminal prompt

Spring Application Events

Today, we are going to implement a simple example using spring application events.

Spring application events allow us to throw and listen to specific application events that we can process as we wish. Events are meant for exchanging information between loosely coupled components. As there is no direct coupling between publishers and subscribers, it enables us to modify subscribers without affecting the publishers and vice-versa.

To build our PoC and to execute it, we are going to need just a few classes. We will start with a basic Spring Boot project with the ‘web’ starter. And, once we have that in place (you can use the Spring Initializr) we can start adding our classes.

Let’s start with a very basic ‘User’ model

public class User {

    private String firstname;
    private String lastname;

    public String getFirstname() {
        return firstname;
    }

    public User setFirstname(String firstname) {
        this.firstname = firstname;
        return this;
    }

    public String getLastname() {
        return lastname;
    }

    public User setLastname(String lastname) {
        this.lastname = lastname;
        return this;
    }

    @Override
    public String toString() {
        return "User{" +
                "firstname='" + firstname + '\'' +
                ", lastname='" + lastname + '\'' +
                '}';
    }
}

Nothing out of the ordinary here. Just a couple of properties and some getter and setter methods.

Now, let’s build a basic service that is going to simulate a ‘register’ operation:

...
import org.springframework.context.ApplicationEventPublisher;
...

@Service
public class UserService {

    private static final Logger logger = LoggerFactory.getLogger(UserService.class);

    private final ApplicationEventPublisher publisher;

    public UserService(ApplicationEventPublisher publisher) {
        this.publisher = publisher;
    }

    public void register(final User user) {
        logger.info("Registering {}", user);

        publisher.publishEvent(new UserRegistered(user));
    }
}

Here we have the first references to the event classes the Spring Framework offers us. The ‘ApplicationEventPublished’ that it will allow us to publish the desired event to be consumer by listeners.

The second reference we are going to have to the events framework is when we create and event class we are going to send. In this case, the class ‘UserRegistered’ we can see on the publishing line above.

...
import org.springframework.context.ApplicationEvent;

public class UserRegistered extends ApplicationEvent {

    public UserRegistered(User user) {
        super(user);
    }
}

As we can see, extending the class ‘ApplicationEvent’ we have very easily something we can publish and listen to it.

Now. let’s implements some listeners. The first of them is going to be one implementing the class ‘ApplicationListener’ and, the second one, it is going to be annotation based. Two simple options offered by Spring to build our listeners.

...
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;

public class UserListeners {

    // Technical note: By default listener events return 'void'. If an object is returned, it will be published as an event

    /**
     * Example of event listener using the implementation of {@link ApplicationListener}
     */
    static class RegisteredListener implements ApplicationListener<UserRegistered> {

        private static final Logger logger = LoggerFactory.getLogger(RegisteredListener.class);

        @Override
        public void onApplicationEvent(UserRegistered event) {
            logger.info("Registration event received for {}", event);
        }
    }

    /**
     * Example of annotation based event listener
     */
    @Component
    static class RegisteredAnnotatedListener {

        private static final Logger logger = LoggerFactory.getLogger(RegisteredAnnotatedListener.class);

        @EventListener
        void on(final UserRegistered event) {
            logger.info("Annotated registration event received for {}", event);
        }
    }
}

As we can see, very basic stuff. It is worth it to mention the ‘Technical note’. By default, the listener methods return ‘void’, they are initially design to received an event, do some stuff and finish. But, obviously, they can at the same time publish some messages, we can achieve this easily, returning an object. The returned object will be published as any other event.

Once we have all of this, let’s build a simple controller to run the process:

@RestController
@RequestMapping("/api/users")
public class UserController {

    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping
    @ResponseStatus(HttpStatus.CREATED)
    public void register(@RequestParam("firstname") final String firstname,
                         @RequestParam("lastname") final String lastname) {
        Objects.requireNonNull(firstname);
        Objects.requireNonNull(lastname);

        userService.register(new User().setFirstname(firstname).setLastname(lastname));
    }
}

Nothing out of the ordinary, simple stuff.

We can invoke the controller with any tools we want but, a simple way, it is using cURL.

curl -X GET "http://localhost:8080/api/users?firstname=john&lastname=doe"

Once we call the endpoint, we can see the log messages generated by the publisher and the listeners:

Registering User{firstname='john', lastname='doe'}
Annotated registration event received for dev.binarycoders.spring.event.UserRegistered[source=User{firstname='john', lastname='doe'}]
Registration event received for dev.binarycoders.spring.event.UserRegistered[source=User{firstname='john', lastname='doe'}]

As we can see, the ‘register’ action is executed and it publishes the event and, both listeners, the annotated and the implemented, receive and process the message.

As usual you can find the source for this example here, in the ‘spring-events’ module.

For some extra information, you can take a look at one of the videos of the last SpringOne.

Spring Application Events

Offtopic: Los sonidos del silencio

¿A qué llamamos silencio hoy en día?

Durante varios días cerca de mi casa ha estado sonando un alarma. Es lo más molesto que os podáis imaginar. Los comentarios más repetidos a mi alrededor han sido todos de protesta por el insufrible ruido y de añoranza del silencio habitual.

Hoy por fin la alarma a parado. Todo ha vuelto a la normalidad, al silencio que tanto añorábamos. ¿Pero realmente esto es así? ¿silencio? Tras unos instantes de felicidad indescriptible por el fin del odioso ruido y los primeros pensamientos de “que gusto de silencio”, me he quedado escuchando un poco más. Con asombro he descubierto que lo que yo, y en general, todos los de mi alrededor tomábamos como silencio no era realmente tal silencio. Se oían multitud de ruidos, coches pasar, niños jugar en la calle, las obras cercanas, … Sin embargo, a pesar de todos estos ruidos de fondo, todos seguíamos pensando que el silencio había llegado, que el silencio que había habitualmente había vuelto.

¿A qué llamamos silencio hoy en día?

Hoy en día el silencio ya no esta tal, estamos tan acostumbrados a vivir en grandes poblaciones con multitud de pequeños ruidos y sonidos, que para nosotros el silencio no es la ausencia de ruido, sino simplemente la ausencia de ruidos que nos molestan especialmente. Nos hemos acostumbrado a ignorar de tal modo los sonidos y ruidos que nos rodean, que podemos pensar que estamos en silencio cuando realmente a nuestro alrededor se oye de todo.

Ahora mismo son las dos y media de la madrugada, y de verdad se puede decir que todo esta en silencio, que no se oye nada, o eso me parece a mi. Quizás mi cerebro simplemente este ignorando los ruidos de fondo que son molestos. No lo sabría decir con seguridad ya que al aguzar el oído, parecen oírse los ruidos de la noche.

¿A qué llamamos silencio hoy en día?

A un montón de sonidos y ruidos de fondo que no son lo suficientemente molestos como para distraernos.

Esta claro que el concepto de silencio a cambiado con los años. ¿Como lo veis vosotros?

Offtopic: Los sonidos del silencio

Offtopic: Origen de …

Como hoy ya estaba un poco aburrido y hastiado de mis tareas y responsabilidades habituales, como se habrá podido observar por el espacio temporal en el que no he publicado nada, he decidido distraerme jugando un poco con las palabras. ¿Qué es esto? Bueno no ha sido más que buscar el origen de algunas palabras a lo largo de los días me han ido llamando la atención. Así que hoy, un post de evasión total, dejando la informática, la ciencia y la tecnología a un lado y dedicándose a algo de uso común, “las palabras”.

Draconiano: Definición de la RAE. Esta palabra se usa para definir algo excesivamente severo o duro. Su origen se debe a Draco o Dracón, un legislador ateniense del siglo VII A.C. famoso por su crueldad, que fue encargado de redactar el código penal. La legislación draconiana castigaba todos los delitos, incluso los más débiles con la pena de muerte. Como decir popular se decía que las leyes no estaban escritas con tinta sino con sangre.

Pasquín: Definición de la RAE. Así se define en escrito anónimo que se fija en un sitio público, con expresiones satíricas contra una corporación, persona o gobierno determinado. La palabra es de origen italiano y hace referencia al nombre de una estatua, la de Pasquino situada cerca de la plaza Navona en Roma. En ella, sobre su pecho, solían fijarse los carteles y escritos críticos contra las autoridades o el papa. El primer pasquín fue dirigido a Urbano VIII por mandar fundir las piezas artísticas de bronce de bronce para fabricar cañones.

Braille: Definición de la RAE. Esta supongo que todos la conoceréis. Es el código de escritura para ciegos. Recibe su nombre del francés Louis Braille (1809-1852). Años después de quedarse ciego en el taller de su padre por accidente a los 4 años, conoció a Charles Barbier, un soldado que había ideado un código para la escritura nocturna. Tras pensar un poco en el sistema del soldado, Louis ideo un sistema simplificado basado en casillas con puntos para tocar con los dedos. Hoy en día Louis reposa en el Panteón de los héroes de Francia.

Eslogan: Definición de la RAE. Esta también es bastante conocidilla. ¿Quien no ha gritado o rememorado alguno? La palabra proviene del ingles “slogan”. Pero esta fue adaptada del gaélico “Sluagh Clairm” pronunciado “slogorm”. Era un grito de combate o llamada a reunión de los viejos clanes escoceses. De ellos paso al ingles, refiriéndose al lema principal de los candidatos a las elecciones, y de ahí paso a muchos otros países y ámbitos del lenguaje.

Boicot: Definición (boicotear) de la RAE. Otra de esas muy conocidas y más hoy en día. Charles Boycott era el administrador de fincas de un terrateniente irlandés en 1880. A pesar de la gran época de hambre, este se negó a rebajar los impuestos que pagaban los jornaleros a su señor. Como medida de protesta pacifica Charles Parnell (lider de la Irish Land League) propuso a los jornaleros dejar de cosechar, vender comido, llevar correo, etc … Finalmente Boycott se fue a Inglaterra y “The Times” uso su apellido para describir la nueva forma de presión.

Piropo: Definición de la RAE. ¿Quien no ha dicho uno? Aunque hoy se usa para describir un halago, antiguamente era una un variedad de granate de color rojo fuego muy apreciado como piedra fina. Por esto tanto Calderón como Quevedo la usaron como metáfora de decir palabras bonitas y así paso al diccionario en 1843.

Bacanal: Definición de la RAE. Esta ha sido fácil. El termino hace referencia a las conocidas fiestas celebradas en el imperio romano en honor del dios Baco, significaba también orgía con mucho desorden o tumulto, que era más o menos como terminaban este tipo de fiestas. Como dato curioso aunque la Iglesia Católica intentó terminar con ellas, no pudo debido a su popularidad y hoy en día se conservan con el nombre de “Carnaval”

La siguiente va por una amiga con la que estuve comentándolo el otro día, tu tenias razón. Yo defendía el “0 Killed” y ella el “all correct”.

OK: No esta en la RAE, pero supongo que todos sabréis lo que es. De esta existe muchas discusiones sobre su procedencia.Una de las más conocidas dice que durante la guerra civil en Estados Unidos, cuando regresaban las tropas a sus cuarteles sin tener ninguna baja, ponían en una gran pizarra “0 Killed” (cero muertos). Otra, es que proviene del “Club OK”, que respaldaba en 1840 la reelección del presidente norteamericano Martin Van Buren, conocido como “Old Kinderhook” (nacido en Kinderhook, Nueva York). Pero, parece que el verdadero origen está en varios artículos aparecidos en 1839 (años antes de la guerra civil y un año antes del Club OK) en el periódico Boston Post en los que para llamar la atención se escribe erróneamente “OK” como abreviatura de “all correct”.

Bueno creo que por hay ya hay bastantes para saciar la curiosidad. Quizás algún día de estrés amplíe el número de entregas. Si alguno conoce algún origen más, que se anime y lo ponga.

Offtopic: Origen de …

Offtopic: ¿La curiosidad se muere?

Que el ser humano es curioso por naturaleza no se puede negar. Desde que somos pequeños cuando no sabemos que es algo, lo cogemos, lo usamos, a veces incluso lo rompiamos, jeje. Pero todo esto con el paso de los años parece que se ha ido perdiendo, sobre todo en la sociedad de hoy en día. En general, cuando algo nuevo llega a nuestras manos, sea lo que sea, software, cacharros electronicos, etc …, lo normal es trastear con ellos, descubrir que hace, como se usa, que otros usos no documentados puede tener. La mente del ser humano es inquieta, necesita averiguar, descubrir, indagar, romper cosas, …

Pero actualmente, parece que la gente esta perdiendo esa curiosidad, no tiene el mas mínimo interes por los comos o los porques. Hoy en día, parece que el pensamiento general es “va porque sí, y si deja de ir lo remplazo (compro otro) y ya esta“.

La gente hoy en día no se preocupa por aprender, ni averiguar, sino por chatear, ver Gran Hermano, Operación Triunfo y demás programas sin ningún tipo de aportación de conocimiento. No recuerdo que en mi infancia hubiesen tantos programas del corazon a la semana. ¿Qué paso con los programas de ciencias para crios? A mi en mi epoca me encantaba verlos, ver como funcionaba el mundo, como funcionaban las cosas. Hoy en día lo mínimo que te llaman por ahi cuando sabes como funcionan las cosas es “friki” o similares(por no poner cosas mas despectivas). Y yo pienso, ¿es motivo de vergüenza? Desde luego a mi no me lo parece, me siento orgulloso cuando me llaman “friki“. Creo que es una costrumbre estupenda interesarse por como funcionan las cosas cotidianas de mi alrededor y las no tan cotidianas. Ademas tanto la sensación de haber comprendido algo como de explicarle a alguien interesado como funciona algo, son estupendas.

¿Quien no jugo con el “Lego“, el “Tente” o el “Mecano” de niño? Todos empezabamos haciendo las figuras del manual y luego acababamos inventando nuestros propio modelos. ¿Por qué lo haciamos? Porque disfrutabamos, y estabamos orgullosos de nuestro nuevo diseño, y lo desmontabamos y haciamos otro. Pero ya parece que eso no es entretenido, ni divertido.

La curiosidad, el interes por descubrir, inventar y crear parece que están desapareciendo y dejando paso ¿a qué? La verdad, no sabría clasificarlo. ¿Qúe opinais vosotros?

Offtopic: ¿La curiosidad se muere?

Offtopic: ¿Ciencia ficción?

Variando un poco la temática habitual, hoy voy a comentar una idea dicha por Stephen Hawking en una entrevista publicada por la BBC. Él afirma que el ser humano para sobrevivir como especie, tendrá que mudarse a otro planeta.

Mas concretamente, ha sido: “Cuando podamos salir al espacio y establecer colonias, nuestro futuro como especie estará asegurado”. En su opinión, la vida en la tierra puede desaparecer por diversas razones, entre ellas un desastre nuclear o el impacto de un asteroide gigante.
Además de esto añadio que, debido a la inexistencia de planetas de similares caracteristicas a la tierra en el sistema solar, deberemos buscar estrellas diferentes. Obviamente esto es una idea descabellada hoy en día debido al tipo de propulsores usados por nuestros actules trasbordadores espaciales, para lo cual, da la solución de usar una propulsión a través de “la aniquilación materia/antimateria”. Esta propulsión viene a basarse en el experimento de que, cuando la materia y la antimateria se encuentran, desaparecen en una fuerte explosión radiactiva. El planteamiento de Hawking, es que si esta energía se usara para propulsar una nave, se podría llegar muy lejos, incluso casi a la velocidad de la luz.

¿Qué os parece la propuesta? ¿Veis a la humanidad en un futuro proximo colonizando otros planetas? ¿Creeis necesaria esta necesidad de colonización espacial?

En el fondo, la idea de Hawking, aunque nos puede sonar muy a ciencia ficción, pensada friamente quizas no sea tan irreal. Actualmente, colisionan contra la tierra cientos de fragmantos de meteoritos. Esta claro que su tamaño es mínimo, y que muchos de ellos se desintegran al entrar en contacto contra la atmosfera, pero ¿no habrá por ahi una grande flotando, esperando ser atraido por la gravedad? O lo que es mas inquietante ¿no habrá uno haciendolo ya que aun no ha sido descubierto? Esto es algo que merece algo mas de investigación. Así que demos gracias a los cientos de telescopios que apuntan diariamente, y de forma constante al cielo para aberiguar lo que pasa por ahi fuera. Muchos podrán pensar en este momento, que con la vigilancia que tenemos del cielo, si algo así fuera a suceder, nos daria tiempo a reaccionar. Pero pensemos esto, a pesar de la fabulosas propulsión que nos proporcionaría “la aniquilación de materia/antimateria”, cosa que aun no esta desarrollada, tardarimos un mínimo de 6 años en llegar a la velocidad de la luz a otro sistema solar, no saquemos cuentas de cuanto tardariamos en trasladarnos todos.

Lo de la catastrofe nuclear, a mi me suena mucho mas a pelicula que lo del meteorito. Esta claro que armas nucleares hay, y muchas, pero parece improblable que se empiecen a usarse mas alla de su efecto amenazante y disuasorio.

Mas alla de todas las catastrofes posibles, esta claro que algun día el Sol se apagará, y para ese entonces o hemos encontrado la forma de emigrar a otra estrella, o hemos encontrado una forma de producir una energía similar o mejor a la que este nos proporciona. Aunque la verdad es que para esto, faltan muchas generaciones. Ya habrá tiempo en el futuro para plantearse este problema.

El gran problema, y que Hawking no ha planteado ni nombrado, creo yo que es que, para llevar a cabo un proyecto de tal envergadura, ademas de la tecnología adecuada, se necesitaría la colaboraciónde todos los diferentes gobiernos, y esto lamentablemente, hoy en dáa parece muy lejano.

¿Pensais que merece la pena plantearse seriamente la posiblidad de exploración y colonización espacial? ¿Algun día nuestros hijos verán en la realidad, lo que nosotros solo hemos visto en peliculas o leido en libros?

Offtopic: ¿Ciencia ficción?