Before you download the documents take into account they are written in Spanish.

FYP: Mejoras a DeTraS: describiendo la actividad humana frente al ordenador.

• Paper
• Slides

Thesis: DeTraS: Ampliación, promoción y creación de una comunidad

• Paper
• Slides

I haven’t talked about DeTraS and CheckApp development for a long time, so I think it’s time to do it.

Currently, time is a scarce resource for me, so I want to spend it working on those things I’m more interested in.

Concerning DeTraS, I have to say I’m a bit disappointed about its evolution. Although I have made a lot of work in the previous months, the applet need to be fixed to work in GNOME3 and Unity, and I haven’t receive enough feedback about the application. Downloads number hasn’t increased in these months, and I’m not quite sure about how many people are using the application. There is also another problem: nowadays a lot of daily tasks are performed in a web browser, and DeTraS would need to

In my opinion, the first step to take in DeTraS development is fix tracked bugs and think how should evolve the project.

CheckApp situation is considerably different. Even though it is a brand new project, I have received some interesting comments about it. Although the project development has just begun, I find it very interesting.

Outside DeTraS and CheckApp, I’m also interested in playing with Git and Android SDK, so I would like to start a small Android application and use Git to maintain its code.

I know there are too much things to do in a small time, but that’s life

Thanks for reading!

This is a maintenance revision of the very first CheckApp release. Although its development has just begun, this is a quite stable release, and it includes some of the most basic features this application should have: user profiles, user relationships, application profiles, built-in notifications, comments and check-apps.

Hey, this is just great but… what does “check-app” mean? Well, it’s just a way to say you are using an application. Maybe it’s the first time you use it, and you want to say “I’ll give it a try”, or perhaps you use that application every day and you want to share it with your friends.

If you don’t want to download the application, this is a screenshot of a test user profile:

CheckApp test user profile

I hope you find it interesting, and I’m waiting for your opinions

Have a nice day!

CheckApp serves as a basis for a new social web application I’m working on. The idea is simple: share with your friends applications you are using, comment them and discover new and useful applications along the way.

Of course, CheckApp is free (both as in freedom and in free beer), so you will be able to install it in your own server or modify its code to fit your needs. Another difference between CheckApp and other social networks is that it will try to minimize the amount of personal information it handles. The idea is to create a social network to have fun and learn new things, not to spy anybody or to be worried about the information you share.

From now on, I will post here tutorials and information about this new project, and I hope you will enjoy those contents.

See you!

Another point I’ve been working on is installation. If you are a proud user of Fedora, you can download DeTraS packages for your distribution. I’m not sure if these RPM packages will work on SuSe or other RPM based distros, so use them under your own responsibility

Finally, you can take a look to a screen-cast I’ve made, giving you a brief overview of DeTraS’ installation and its main features. You can watch it on Youtube or download it here.

Have fun!

As you will know, I’ve released DeTraS 0.5.0 recently, and I’ve been messing around with packaging again. I remember that packaging DeTraS 0.4.2 was a pain in the neck, specially because I had some troubles to upload a working version of the package to my PPA, so this time I’ve been playing with some other utilities to make it easier.

In first place, I still recommend you to read Debian New Maintainers’ Guide. It will help you to understand what is going on the process of creating a Debian package. Anyway, this time I have an additional guide for you. In my opinion it is another must if you want to build Debian packages, because it has a lot of information, it is easy to read and it is updated. I’m talking about the Complete Packaging Guide on Ubuntu Wiki.

Another topic of the former post was chroot. I still encourage you to use chroot, but instead of using it directly as I did in the past, I highly recommend you to employ pbuilder to handle your chroot.

Pbuilder provides a clean environment where you can build Debian packages just based on dependencies you have set on your package. Isn’t that what chroot provides? Not really, because when you create a chroot manually you have to install needed packages by yourself, leading to a dirty installation, where you will have extra packages, maybe including some dependencies you haven’t set on your package. In this case, you will be able to build your package on your chroot, but not outside it. Using pbuilder you will avoid this problem, because every time you build a package using it, it will install needed dependencies for your package and it will clean your chroot after built to keep a minimal installation. A good guide to use pbuilder is Pbuilder Howto on Ubuntu Wiki.

After all this information, we can start building a package:

Build a source package

This option will provide you a base to build a binary package on your system or in a repository. Follow these steps to generate a source package:

1. Given a tarball of the program you want to create a package, uncompress it and go to its root directory.
2. If you are using autotools to generate your configuration script and Makefile, execute:
   

   ./autogen.sh

3. Now run:
   

   dh_make -f ../<tarball-package>

   
   to generate an orig.tar.gz file and skeleton of needed files to build your package.
4. Modify files under debian directory as Debian New Maintainers’ Guide and Complete Packaging Guide recommend.
5. Once you are ready, generate the package by executing:
   

   debuild -S

   
   or:
   

   dpkg-buildpackage -S

Build a binary (deb) package

The following steps will generate Debian packages for your application:

1. In most of the cases, if it’s the first time you use pbuilder, you will want to have multiple pbuilders for different distributions or architectures. Here is the method I have followed to achieve this behaviour.
2. Create your pbuilder executing this command:
   

   sudo DIST=karmic ARCH=i386 pbuilder create

   
   As you can see, you can specify distribution and architecture of your pbuilder (Ubuntu Karmic on a i386 machine on this example). If you followed instructions on previous step, you can create several pbuilder for diferent distros and architectures. You only need to do this step the first time you use pbuilder. If you have already created a pbuilder, you should update it before building (see step 5).
3. Now it’s time to build your package by executing:
   

   sudo DIST=karmic ARCH=i386 pbuilder build <package>_<version>.dsc

4. If everything goes right, you can get resulting packages on /var/cache/pbuilder/<distribution>-<architecture>.
5. If you want to update your pbuilder environment, all you have to do is to execute
   

   sudo DIST=karmic ARCH=i386 pbuilder update

That’s all for now. I hope you find this guide useful

DeTraS Overview - Global view

These days I’m working to improve documentation and preparing a surprise. Oh, I’m also planning future changes, so if you have an interesting feature you want to see in DeTraS, just let me know

Have a nice day!

This blog is a source of news and information of DeTraS project development, so some posts may require computing technical skills. Anyway, if you are not interested in that type of contents, you may find interesting this project and news related to it.

In case you are interested, you can find more about DeTraS project here, and more about myself and objectives of this blog here.

As this is my first post in LinuxPlanet, I would like to introduce myself and give you a quick review of the topics you can find on this blog.

In first place, my name is Edmundo Álvarez and I’m a computer scientist who lives in Spain. I started working in DeTraS (acronym of Developing Tracking System) about a year and a half ago, as part of my FYP.

DeTraS is a set of tools that works on GNU/Linux (in an X window system) and allows you to track the usage of your system, get information about tracked data and upload them to a server for analysis purposes.

This blog is mainly a site to place DeTraS’ news and information I found interesting about its development.

In case you are interested, you can find more about DeTraS project here, and more about myself and objectives of this blog here.

The first step is to find a way to draw charts and graphs. After looking for an easy and lightweight Python module to perform this task, I decided to try with Pycha. It’s really simple to generate a plot using it, so I think you’ll be able to draw a chart just hacking a bit with these examples (included in Pycha’s code).

Example of chart using Pycha and PyGTK

Now, you should paint a chart in your GUI. PyGTK provides a class to perform drawings on the screen, called DrawingArea. The best way to use this class is creating a subclass and implementing some methods to draw and handle some signals. In my case, I wanted to show several types of plots, so I’ve created an abstract class called Plot, which is a subclass of DrawingArea and it’s the parent of LinePlot and VBarPlot classes, which will hold and paint a line chart and a vertical bar chart respectively.

Once you have a class extending DrawingArea, you need to implement two methods to handle expose_event and size-allocate signals. The expose_event signal will be fired every time your DrawingArea is shown or it has to be redrawn. The size-allocate signal will be fired when the window that holds your DrawingArea is resized.

I’m sure you would rather want to see some code instead of reading more boring explanations about what I’ve done. No problem, this is the code of Plot class:

class Plot (gtk.DrawingArea):
    def __init__ (self):
        gtk.DrawingArea.__init__(self)
        self.connect ("expose_event", self.expose)
        self.connect ("size-allocate", self.size_allocate)
        self._surface = None
        self._options = None

    def set_options (self, options):
        """Set plot's options"""
        self._options = options

    def set_data (self, data):
        pass

    def plot (self):
        pass

    def expose (self, widget, event):
        context = widget.window.cairo_create ()
        context.rectangle (event.area.x, event.area.y,
                event.area.width, event.area.height)
        context.clip ()
        self.draw (context)
        return False

    def draw (self, context):
        rect = self.get_allocation()
        self._surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, \
                rect.width, rect.height)
        self.plot ()
        context.set_source_surface (self._surface, 0, 0)
        context.paint ()

    def size_allocate (self, widget, requisition):
        self.queue_draw ()

And these is LinePlot class:

class LinePlot (Plot):
    def __init__ (self):
        Plot.__init__ (self)

    def set_data (self, data):
        """
        Update plot's data and refreshes DrawingArea contents. Data must be a
        list containing a set of x and y values.
        """
        self._data = (('Data', data),)
        self.queue_draw ()

    def plot (self):
        """Initializes chart (if needed), set data and plots."""
        chart = LineChart (self._surface, self._options)
        chart.addDataset (self._data)
        chart.render ()

If you want to see the complete source file, you can find it here.

Nice hacking