Department of Chemistry

...California State University Stanislaus

  • Increase font size
  • Default font size
  • Decrease font size
Home News Feeds Planet Ubuntu
Planet Ubuntu
Planet Ubuntu -

  • Matthew Helmke: The Maker’s Guide to the Zombie Apocalypse

    The Maker’s Guide to the Zombie Apocalypse is a fun book. It uses a (fictional?) story of preparation for a coming zombie invasion to weave a narrative that presents a use case for an interesting set of electronic projects. The projects are all centered on survival; specifically, the things you are likely to find most useful in a situation where the electrical grid has failed and you find yourself surrounded by hostile forces. The progression of chapter topics is logical and each build upon the previous.

    We start with a both fun and well-thought-out description of the problem, an overview of what a zombie apocalypse might look like. Here we learn what we are up against. Starting with chapter two, we work to mitigate against the various problems and threats to enhance our potential for survival.

    Included topics include generating and storing electricity, building alarms and surveillance monitors, remote access and open door detection, environmental monitoring, and then wiring it all together into a control center. Additional topics include ways to distract the attention of zombies and different forms of confusion with other survivors.

    This alone would make the book enjoyable and useful to anyone interested in these sorts of electronic projects. However, the book does not end here. Included are three useful appendices with information about acquiring and understanding electronic parts and tools, learning basic skills, and a primer on one of the two control modules used in projects in the book, the Arduino. The other, the Raspberry Pi, is less complicated and requires less instruction for the uses in this book.

    I thoroughly enjoyed this book and think that anyone with similar interest in electronics would, too.

    Disclosure: I was given my copy of this book by the publisher as a review copy. See also: Are All Book Reviews Positive?

  • Sebastian Kügler: Plasma Components on Android: Accelerating Subsurface Mobile Development

    Marco has come over to the Netherlands to pay me a visit, and to hack a little bit together, in person. So with the weather clearly suggesting to stay inside, that’s what we did over the weekend, and how better to entertain yourself than to work on mobile software?

    Marco has been working for a while on components that follow Plasma’s human interface guidelines and make it easy to implement applications with a common navigation pattern and look and feel. Obviously, these components use a lot of Plasma under the hood, so they get excellent integration at a visual and at a technical level. This high integration, however, comes at the price of having a non-trivial chain of dependencies. That’s not a problem om Plasma Mobile, or other Plasma workspaces, since all that is already there, anyway.
    We thought that an interesting exercise would be to find out what really defines a “Plasma application”, and how we can make the concepts we engrained in their design available to application developers more easily. How hard could it be to use Plasma components in an Android app, for example? The answer is, not entirely trivial, but it just became a whole lot easier. So what did we do?

    For those reading this article via a feed aggregator, hop over to youtube to watch the demo video.
    We took Subsurface, which is a piece of Free software used for logging and analysing scuba dives. Subsurface is a mobile version, which is still in its infancy, so it’s an excellent candidate to experiment with. We also took Marco’s set of Plasma components that provide a reduced set of functionality, in fact, just enough to create what most applications will need. These components extend QtQuick components where we found them lacking. They’re very light weight, carry no dependencies other than QtQuick, and they’re entirely written in QML, so basically, you add a bunch of QML files to your app and concentrate on what makes your app great, not on overall navigation components or re-implementing for the n-th time a set of widgets.

    So after solving some deployment issues, on Saturday night, we had the Plasma mobile components loading in an Android app. A first success. Running the app did show a number of problems, however, so we spent most of the Sunday to look into each problem one by one and trying to solve them. By early Monday morning, we had all of the glaring issues we found during our testing solved, and we got Subsurface mobile to a pretty solid appearance (pretty solid given its early state of development, not bug free by any means).

    So, what to take a away from this? In a reduced form, Plasma can be a huge help to create also Android applications. The mobile components which we’re developing with Plasma Mobile as target in mind have had their first real world exposure and a lot of fixes, we got very useful feedback from the Subsurface community which we’re directly feeding back into our components.

    A big thanks goes out to the Subsurface team and especially Dirk Hohndel for giving us excellent and timely feedback, for being open to our ideas and for willing to play guinea pig for the Plasma HIG and our components. The state you can see in the above video has already been reviewed and merged into Subsurface’s master tree, so divers around the world will be able to enjoy it when the app becomes available for a wider audience.

  • Ronnie Tucker: Gentoo-Based Sabayon Linux 15.12 Is Out, Raspberry Pi 2 Version Incoming

    Sabayon Linux 15.12 is an operating system designed for Linux enthusiasts who want the latest packages and the best performance. This is a system based on Gentoo, which is known for its reliability.

    Let’s face it, there aren’t too many Gentoo-based operating systems out there, but Sabayon is proof that you can also use other bases than some of the big names like Debian, Fedora or Arch. It employs a rolling release model, which means that changes and improvement are pushed on a constant basis, and each month the ISO is regenerated with the latest packages.

    Sabayon is also a system that provides the newest packages from the Gentoo repositories, making sure that it stays up to date. This way, users have the latest KDE, GNOME, or LibreOffice software. This makes Sabayon one of the few bleeding-edge Linux distributions that put emphasis on new and interesting rather than old and stable.

    Submitted by: Arnfried Walbrecht

  • Robert Ancell: Accessing a JSON webservice using libsoup and JSON-GLib
    A lot of web services use the JSON format. If you are working a GLib based project and need to access a service like this there are two great libraries to help you - libsoup and JSON-Glib.

    For my example, I'm going to grab some review data from Ubuntu (API) which looks something like this:

            "ratings_total": 229,
            "ratings_average": "3.84",
            "app_name": "",
            "package_name": "simple-scan",
            "histogram": "[35, 13, 22, 42, 117]"
            "ratings_total": 546,
            "ratings_average": "4.66",
            "app_name": "",
            "package_name": "audacity",
            "histogram": "[17, 7, 17, 63, 442]"


    The data is a single array of objects that contain the statistics for each package. For this example I'll print out the number of ratings for each package by getting the package_name and ratings_total members from each object.

    Firstly, I need to download the data. The data is retrieved using a HTTP GET request; in libsoup you can do this with:

        SoupSession *session = soup_session_new_with_options (SOUP_SESSION_USER_AGENT, "test-json", NULL);
        SoupMessage *message = soup_message_new (SOUP_METHOD_GET, "");

        soup_session_send_message (session, message);

    Now I have the server text in message->response_body->data but it needs to be decoded. JSON-GLib can parse it with:

        JsonParser *parser = json_parser_new ();
        json_parser_load_from_data (parser, message->response_body->data, -1, NULL);
        JsonNode *root = json_parser_get_root (parser);

    Now I have an in-memory tree of the JSON data which can be traversed. After checking the root node is an array as expected I'll iterate over each object:

        g_assert (JSON_NODE_HOLDS_ARRAY (root));
        array = json_node_get_array (root);
        for (i = 0; i < json_array_get_length (array); i++)
            JsonNode *node = json_array_get_element (array, i);

            /* do stuff... */

    For each object, I extract the required data:

            g_assert (JSON_NODE_HOLDS_OBJECT (node));
            JsonObject *object = json_node_get_object (node);
            const gchar *package_name = json_object_get_string_member (object, "package_name");
            gint64 ratings_total = json_object_get_int_member (object, "ratings_total");
            if (package_name)
                g_print ("%s: %" G_GUINT64_FORMAT "\n", package_name,

    Combined into a program, I can print out the number of reviews for each package:

    simple-scan: 229
    audacity: 546

    The full program:

    // gcc -g -Wall example-json.c -o example-json `pkg-config --cflags --libs libsoup-2.4 json-glib-1.0`


    int main (int argc, char **argv)
        SoupSession *session;
        SoupMessage *message;
        guint status_code;
        JsonParser *parser;
        gboolean result;
        JsonNode *root;
        JsonArray *array;
        gint i;

        /* Get the data using a HTTP GET */
        session = soup_session_new_with_options (SOUP_SESSION_USER_AGENT, "test-json", NULL);
        message = soup_message_new (SOUP_METHOD_GET, "");
        g_assert (message != NULL);
        status_code = soup_session_send_message (session, message);
        g_assert (status_code == SOUP_STATUS_OK);

        /* Parse the data in JSON format */
        parser = json_parser_new ();
        result = json_parser_load_from_data (parser, message->response_body->data, -1, NULL);
        g_assert (result);

        /* The data should contain an array of JSON objects */
        root = json_parser_get_root (parser);
        g_assert (JSON_NODE_HOLDS_ARRAY (root));
        array = json_node_get_array (root);
        for (i = 0; i < json_array_get_length (array); i++)
            JsonNode *node;
            JsonObject *object;
            const gchar *package_name;
            gint64 ratings_total;

            /* Get the nth object, skipping unexpected elements */
            node = json_array_get_element (array, i);
            if (!JSON_NODE_HOLDS_OBJECT (node))

            /* Get the package name and number of ratings from the object - skip if has no name */
            object = json_node_get_object (node);
            package_name = json_object_get_string_member (object, "package_name");
            ratings_total = json_object_get_int_member (object, "ratings_total");
            if (package_name)
                g_print ("%s: %" G_GINT64_FORMAT "\n", package_name, ratings_total);

        /* Clean up */
        g_object_unref (session); 
        g_object_unref (message);
        g_object_unref (parser);

        return 0;

    And to show you can do the same thing with GIR bindings, here's the same in Vala:

    // valac example-json.vala --pkg soup-2.4 --pkg json-glib-1.0

    public int main (string[] args)
        /* Get the data using a HTTP GET */
        var session = new Soup.Session.with_options (Soup.SESSION_USER_AGENT, "test-json");
        var message = new Soup.Message ("GET", "");
        assert (message != null);
        var status_code = session.send_message (message);
        assert (status_code == Soup.Status.OK);

        /* Parse the data in JSON format */
        var parser = new Json.Parser ();
            parser.load_from_data ((string);
        catch (Error e)

        /* The data should contain an array of JSON objects */
        var root = parser.get_root ();
        assert (root.get_node_type () == Json.NodeType.ARRAY);
        var array = root.get_array ();
        for (var i = 0; i
            /* Get the nth object, skipping unexpected elements */
            var node = array.get_element (i);
            if (node.get_node_type () != Json.NodeType.OBJECT)

            /* Get the package name and number of ratings from the object - skip if has no name */
            var object = node.get_object ();
            var package_name = object.get_string_member ("package_name");
            var ratings_total = object.get_int_member ("ratings_total");
            if (package_name != null)
                stdout.printf ("%s: %" + int64.FORMAT + "\n", package_name, ratings_total);

        return 0;

    and Python:


    from gi.repository import Soup
    from gi.repository import Json

    # Get the data using a HTTP GET
    session = ()
    session.set_property (Soup.SESSION_USER_AGENT, "test-json")
    message = ("GET", "")
    assert (message != None)
    status_code = session.send_message (message)
    assert (status_code == Soup.Status.OK)

    # Parse the data in JSON format
    parser = Json.Parser ()
    parser.load_from_data (, -1)

    # The data should contain an array of JSON objects
    root = parser.get_root ()
    assert (root.get_node_type () == Json.NodeType.ARRAY)
    array = root.get_array ()
    for i in xrange (array.get_length ()):
        # Get the nth object, skipping unexpected elements
        node = array.get_element (i)
        if node.get_node_type () != Json.NodeType.OBJECT:

        # Get the package name and number of ratings from the object - skip if has no name
        object = node.get_object ()
        package_name = object.get_string_member ("package_name")
        ratings_total = object.get_int_member ("ratings_total")
        if package_name != None:
            print ("%s: %d" % (package_name, ratings_total))

  • Costales: Ubucon París 15.10

    Viernes, 27 Noviembre

    Llevaba tiempo con ganas de ir a la Ubucon de París, una de las más famosas :) Además, para esta se animó Fernando Lanero :D así que será nuestra segunda Ubucon (¡qué recuerdos de Colombia!).

    Are you ready?

    Tras el vuelo y trenes de rigor, dejamos las cosas en el hotel y nos dirigímos al bar donde habían quedado algunos organizadores, después de montar todo el chiringuito para los próximos dos días.

    Ahí tuvimos la suerte de compartir unas pizzas y cervezas con parte de Ubuntu Francia; Olivier nos convenció de por qué el Lenovo X201 es el mejor portátil (¡quiero uno! ;P) y convencimos a Matthieu de que se quedara más tiempo gracias al líquido ambar ;P Llevaba mucho tiempo con ganas de conocer a Rudy, en persona se confirmó que es un hombre excepcional.




    En la noche, el frío y la lluvia nos acompañó hasta el hotel.

    Sábado, 28 Noviembre

    ¡Primer día de Ubucon! Nos levantamos temprano para estar a primera hora en el edificio de la Ciudad de las Ciencias.

    Allí estaba Vincent :)) ¡Qué alegría verle! Pues no coincidíamos desde el evento de Insiders en Londres. También conocí a Simon, David Callé y Nicolas, quedría haber podido compartir más tiempo con ellos :)




    ¿Y qué decir de la Ubucon? ¡Impresionante! Nos sentimos como en casa, su hospitalidad fue extraordinaria. La organización perfecta, el sitio genial, las conferencias y talleres muy interesantes y atiborrados de gente.












    Me pasé el día de conferencia en conferencia, paseando por la zona de asociaciones como Mozilla, Wikipedia o Framasoft donde conocí a Genma, quien transmite muchísima pasión hablando de la libertad.También ví por primera vez la convergencia de Ubuntu :D Y os aseguro que es una pasada :D
    Desde aquí quiero agradecer a Francis, muy majo, su ayuda con la traducción de mi charla.

    El día se me pasó volando, tanto, que cuando me dí cuenta, estabamos en el bar para cenar juntos 46 compañeros ubunteros, sí, 46 :O nos adueñamos del bar :P Ahí conocí a Quest, quien graba los podcast de Ubuntu France.


    La velada la finalizamos en otro bar, compartiendo ídeas para solucionar el mundo :)

    Domingo, 29 Noviembre

    ¡Y segundo día de la Ubucon! O más bien, nuestro segundo medio día, pues el vuelo sale por la tarde. Aún así, dió tiempo a ver un par de conferencias y volver a sorprendernos de la cantidad de personas que asisten a interesarse por Ubuntu. Y además Matthieu nos enseñó los talleres de Fablab, uf, ahí podríamos pasar días enteros, una pasada.


    Con más tiempo, experimenté más con el ordenador de exposición que muestra la convergencia y pude probar uNav en modo escritorio :P


    Asistir a una Ubucon es una experiencia única y totalmente recomendable. Vuelvo con muchos amigos nuevos.
    Espero veros pronto compañeros |o/

    and future :)
    Lovely game and guy!

    Awesome Ubucon!
    Tienes más fotos de Ubuntu-FR aquí.