Getting back with the Django Logic

These past weeks I have gone back to my Django resources to try to learn the last stages of the Django modules, business logic, etc.

I most say that I have actually skip most of the documentation and gone into more trusty tutorials that do one task, and learn from it.

One of the tutorials I found was for the CRUD system, something basic enough to grasp it easily. However, even then it wasn’t as easy as I thought.

The writer develop an internal debate between a Class based view, and a Function based views. As you know, Views is where the business logic of the applications are. So even if this learning was good and simple, I might need to multiply it by 2. Not that is necesarily bad, but still, wish it was simple.

I went to a DjangoCon videoset on youtube. One of those was about teaching Django at University, and there was a very interesting explanation on how Django sometimes is unecesarily complicated. Also some recomendations like the Django Girls group, and a book called Two Scoops of Django, something that I already had on my resources.

This gave me some idea into their philosophy. Hearing someone recognizing that the documentation is not always the best way for learners to understand whats going on. Building on top of an understandment is something that is helpful for learners build their best interpretations.

Telling a n00b to study this documentation with everything you will ever needed inside doesnt mean he would actually go through it all. On other words, most people will rather create a fix for their inmediate need.

At the moment some of these needs are:
– Creating a cookbook
– Creating mentoring mechanisms
– Generating 50 shot view of whats going on

OpenData and XML

I have been working with XML for a while, OpenOffice is full of XML, from the XCU to the filetype OpenDocument Format, worked as an umbrella format for many other types of XMLs, including popular w3c proposals like the Dublin core as well as other URIs and schema.

OpenOffice actually has an XForm editor, that is somewhat misleadingly named as XML document.

A few days back I gave a talk on Bitcoin which turned me on to check out OpenData initiatives as well as the importance of open standards. Looking at the local OpenData initiative I found it a bit odd that the implementations were so shallow. As they focused more on systems than on actual key elements like defining structured data and implementing interactive APIs for it.

This sent me to research defined standards for common organizational logic including geospatial, e-business, legal and financial standards. Adopting these standards play an important role and also a good way to produce code that can help the OpenOffice platform as well as systems built for it.

The importance of XML and the lack of awareness of the importance of interoperability for data is something key to the OpenData movement as well as increasing the knowledge of productive stacks that can generate interactions with it. Not just to create, consume, and convert but also to standardize on it and create the business cases for it.

This pulled me into looking back into my own domain of standard. The OpenDocument format and OpenOffice XForm as a medium to expand the applications and interaction of the suite to generate more compatibility with this.

Looking at this, I will work on generating new and exciting projects aimed at creating the extensions, components and filters for making OO a more intelligent platform designed for OpenData improvement.

New technology research

nodejs screen

Node.js is becoming really strong on the web development space. Just like HTML5 and their Javascript resurgence the need to learn Javascript more and more is becoming omnipresent when you step into node.js.

Node.js is basically Javascript on the server, and like such, a lot of things change in the space of webdevelopment. People relying on other languages like Java, Python, or Ruby to generate Javascript now face a web with the opposite, Javascript replacing everything and even promising to start generating machine code FROM javascript. Like Hiphop but for JS.


This is the other big technology for big data. Hadoop is becoming something that a lot of dba’s are getting on board. Hadoop is the Mapreduce strategy for big data, based on Java

Rather than rely on hardware to deliver high-avaiability, the library itself is designed to detect and handle failures at the application layer, so delivering a highly-availabile service on top of a cluster of computers, each of which may be prone to failures. Seems these projects would be great steps to modernize my skillset on current technologies.

Something that I have been starting to do si to join groups in Linkedin and Facebook about the technologies.

So far I have joined Python, HTML5 and Node.js groups where one of the big advantages is locating resources and job opportunities on the technology.

Interns to me

Today I got emails from our spaniard college where we finally got the documents to work upon the internships in Europe. We won’t be offering payment unfortunately but they will surely be able to be part of the efforts happening in as they are starting to generate some code. These students will be able to build and provide documentation on it. Also some will need to be able to code some mid-size code to have an acknowledgement of their program. 

For exmaple:

  • Core developers will first need to compile and run OOo from current source. From then they will need to learn about services and interfaces and optimize some parts of the suite. Some goals can include – improve the Draw interface, improvde the way calc functions get built, a GUI way to design dialogs for Java, a Python framework for UNO with more RAD driven code.
  • Extension development will focus on create new extensions as well as improve some of the ones available. Several projects such as digital signature extensions, improved GUI and instant signature for some specific devices. 

These efforts would be need to start getting accumulated until we can have a productive suite. I was pleased that the spaniard university will assign as much as 6 students per profile (would need to verify) but the skillset will be great for them and for us as well. If the students don’t acomplish their goals, it would still serve for their knowledge of the software as well as me. Working together will allow the patches to be commited and also tested and quality approved in one sole package.

Monkeying around the line of hard and dynamic code

So a few months back I had a discussion about the difference of using the 3rd party binding across dynamic languages. This is nothing new, and there has been quite a few of these bridges. However I am not sure how much has these been taking up.

The conversation was a comparison between using C# or other languages like Ruby for .NET. Granted that this was not really a .NET conversation but rather on the options in coding under the same API or VM. The JAVA version of the conversation would have been between things like using Java to use JVM or using something like JRuby or the more rooted language Groovy.

So after this conversation I went to understand the question better. Is really a whole new language needed to use an API? Should we just start becoming language driven as opposed of API/VM driven? After all given the options out there, these seem like a viable option.

So I have two different roads, one was making easy things (dynamic approach) to hard languages (JAVA), and using hard languages on toolkits that are usually develop with dynamic languages (GTK). So I took a look at some of the following implementations:

  • Using Jython with SWING
  • Groovy cookbook and hello world
  • Gnome-Java
  • GTK in C
  • PyGTK

So here are some snippets about how to use Jython with SWING (Java GUI Toolkit).

from javax.swing import JFrame

JFrame(‘Hello, World!’, defaultCloseOperation=JFrame.EXIT_ON_CLOSE, size=(300, 300), locationRelativeTo=None).setVisible(True)

This simple two line code will generate already a window, label and action.

The next example is the opposite, and doing a Toolkit like GTK in Java language:

package button;

import org.gnome.gdk.Event;
import org.gnome.gtk.Button;
import org.gnome.gtk.Gtk;
import org.gnome.gtk.Label;
import org.gnome.gtk.VBox;
import org.gnome.gtk.VBox;
import org.gnome.gtk.Widget;
import org.gnome.gtk.Window;

public class ExamplePressMe
public static void main(String[] args) {
final Window w;
final VBox x;
final Label l;
final Button b;


w = new Window();
x = new VBox(false,3);
l = new Label(“Go ahead:nMake my day”);
b = new Button(“Press me!”);

b.connect(new Button.Clicked() {
public void onClicked(Button source) {
System.out.println(“I was clicked: ” + b.getLabel());
w.setTitle(“Hello World”);
w.connect(new Widnow.DeleteEvent() {
public boolean onDeleteEvent(Widget source, Event event) {
return false;


Pardon my verbosity but half is becaus of JAVA and half is because of GTK. However we can see here that is just a matter of declaring variables classes and execution. Now we move to the C version:

#include <gtk/gtk.h>

static void hello( GtkWidget *widget, gpointer data ) {
g_print (“Hello Worldn”);

static gboolean delete_event ( GtkWidget *widget, GdkEvent *event, gpointer data ) {
g_print (“delete event occurredn”);
return TRUE;

static void destroy ( GtkWidget *widget, gpointer data ) {

int main( int argc, char *argv[] ) {
GtkWidget *window;
GtkWidget *button;

gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (window, “delete-event”, G_CALLBACK (delete_event), NULL);
g_signal_connect (window, “destroy”, G_CALLBACK (destroy), NULL);
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
button = gtk_button_new_with_label (“Hello GTK+”);
g_signal_connect (button, “clicked”, G_CALLBACK (hello), NULL);
g_signal_connect (button, “clicked”, G_CALLBACK (gtk_widget_destroy), window);
gtk_container_add (GTK_CONTAINER (window), button);
gtk_widget_show (button);
gtk_widget_show (window);
gtk_main ();

return 0;


Frameworks, link share and entrepreneurial investments

So since I have been living here in Cancun I have been involved with this developers meetup where we talk and share impressions and comments around development topics. Things like frameworks, languages, best practices and also just have fun with new applications and discoveries. All these took part on last meetup we had yesterday.

The atendee list was small even if many more verified their assistance. A total of four developers gather, most of them I already knew from previous sessions however a new face showed up to this meetup. Some great applications where shared during our meetup including an application similar to the Illumination software creator, which generate applications for Linux, Windows, OSX, Iphone, Andorid and so on, but a new one called Titanium. The whole toolkit is based on Javascript and then generated into the native language. Quite similar to the Illumination software except is a pygtk generation and flex.

Other topics were circulating including the troubleshooting of a JQuery module for the use inside a site. While some hacking was going on an interesting discussion which I decided to record about the differences between the frameworks and MVC model versus the traditional way of developing web applications.

The discussion was pretty interesting and the comments about Python vs PHP and how MVC can be applied to certain applications. There was also some link sharing including Woopra, an alternative to Google Analytics. which acts as a monitor of your time spent in at the workstation and teach you how to save time between the applications you are working at.

There was a small discussion about hosting services and cloud services versus VPS and smaller shared accounts, on price point and also cloud services. From local backup to Carbonite and similar cloud services which I am not very found off. My philosophy on using linux for example has changed the way I percieved hardware and when making a selection on netbooks or laptops I just see a shell to my information that lives on different devices as opposed on planning and saving for just 1 expensive piece of tech.

The last part of the meetup was quite interesting, we change scenery and went to a Wings Army which was a good time to throw some food. We were able to talk about the business side of entrepreneurship. We went from venture capitals in Mexico to a directory of south california investments. He told me his experience with government funding and how corruption brought the whole thing down. Something unfortunately very common in the government.

Eventually going back to stories about how to look for greener pastures and try to refocus the strategy and how to avoid huge ammount of paperwork to get by the funding of the solution. I shared my personal strong critics to the Mexican ‘investors’ being completely missplaced as far as what market capitalization vs monetization and growth. As many would notice, Google, twitter, and even Facebook, monetization was always pushed further and delayed as much as possible, even now at 50+ billion dollars there still not substantial monetization yet investment is now pouring from every angle.

Organizing for the new year the FLOSS way

So a good Free Software new year wishes is to start organizing Free software events for this year. There are several events where we can put our community on the map. Each year events such as Document Freedom Day, Software Freedom Day, FLISOL and the multiple FLOSS applications events. My initial thought is to cover them via streaming, the multiple talks in different places and countries makes me impossible to look this as a phisical thing but more as a broadcasting thing. Tunning in on a specific hour to a on-going talk about the relevant event seems like the best thing to start going at it.

Things like an on-going IRC channel for the different “ES” regions that can just connect during that day and have a distributed conversation about the events seems like the best idea. However organizing small events is also something I would like to get involved and see what can be done in that area as well as get involved with networking of geeks in my local area.

Some of the issues is that I am new to the area, also my geek friends are increasing but not at the rate that I would have expect at first. So I would like to have a stronger social network that come together into making more geeky things through the network. Also having some more spare change wouldn’t hurt. Being able to access to university resources, tackle on innovation from a larger userbase like maybe a school or medium company that can get involved into providing a cookout or a location that we can all collaborate on making it better. This remind me of a place like LinuxCabal where in Guadalajara was very very active, this gave us a great position where we can all geekout.

I guess my larger goal is to have that people and have that place to geekout and strenght the geek metropolitan network. Till next time, these events will tell if I made it or not.