Bottle, full stack without Django

This blogpost is based in a lecture I presented here in Brazil, follows the slides!

Bottle is a micro web framework compatible with WSGI, depends only on the Python standard library is compatible with python 2.6, 2.7, 3.2, 3.3 and 3.4, single source file. It was created by Marcel Hellkamp (@defnull) and maintained by the community that raised surrounding framework.

Django is a framework for rapid development for web, written in Python, which uses the standard MTV (model-template-view) and pragmatic. Was originally created as a system to manage a journalistic site in the city of Lawrence, Kansas. Became an open source project and was published under a BSD license in 2005. The name Django was inspired by the jazz musician Django Reinhardt. Django became very known for having included batteries, i.e. several distributed libraries join the Centre of the framework for simplicity work (called “full stack”).

Pragmatic is what contains practical, realistic considerations, with well-defined target. Be pragmatic is to be practical is to have goals defined. In other words, the team that developed the Django take some description of architecture and who uses Django follows this architecture without being able to change easily.

It's good a web framework have batteries included? Depends, if you use everything that the framework gives you Yes, but not all web designs are the same.

Many project does not use 80% than Django offers, in those cases that don't use more than 50% of what we pay the cost of offering Django someone have defined the architecture, i.e. lost in performance because the Django has many modules that will not be using and yet he will climb a few modules that we don't use. When we use a micro framework we do the role of architect of application development, since we don't have a set before architecture begins to develop is necessary to devote time to define the architecture of the application.

All the packages that we have on the Django Python library that can substitute for use in a micro framework!

• ORM - SQLAlchemy to bottle-sqlalchemy
• Forms - WTForms
• Template Engine - Jinja2, mako, etc
• Migration - Alembic

SQLAlchemy

The SQLAlchemy exists before Django (yes before Django) and since 2005 we have a team focuses on development of an ORM, unlike Django it's a time to take care of a web framework + ORM (I believe I don't need to talk to a developer focused render more than a developer not focused).

Structure of a model:

class Entity(Base):
    __tablename__ = 'entity'
    id = Column(Integer, Sequence('id_seq'), primary_key=True)
    name = Column(String(50))

    def __init__(self, name):
        self.name = name

    def __repr__(self):
        return "<Entity('%d', '%s')>" % (self.id, self.name)

WTForms

A workaround for those who do not use Django and need to work with forms we have the WTForms, was created in 2008 and maintained until today!

Structure of a form:

class UserForm(Form):
    name = TextField(validators=[DataRequired(), Length(max=100)])
    email = TextField(validators=[DataRequired(), Length(max=255)])

Template Engine

Jinja2 is a modern and designer-friendly templating language for Python, modelled after Django’s templates. It is fast, widely used and secure with the optional sandboxed template execution environment

Structure of a template:

<title>{% block title %}{% endblock %}</title>
<ul>
{% for user in users %}
  <li><a href="{{ user.url }}">{{ user.username }}</a></li>
{% endfor %}
</ul>

Migration

Usage of Alembic starts with creation of the Migration Environment. This is a directory of scripts that is specific to a particular application. The migration environment is created just once, and is then maintained along with the application’s source code itself.

Structure of a migration:

revision = '1975ea83b712'
down_revision = None

from alembic import op
import sqlalchemy as sa

def upgrade():
    pass

def downgrade():
    pass

How to make the evolution and downgrade:

def upgrade():
    op.create_table(
        'account',
        sa.Column('id', sa.Integer, primary_key=True),
        sa.Column('name', sa.String(50), nullable=False),
        sa.Column('description', sa.Unicode(200)),
    )

def downgrade():
    op.drop_table('account')

Structure of a alter table:

"""
$ alembic revision -m "Add a column"
"""

revision = 'ae1027a6acf'
down_revision = '1975ea83b712'

from alembic import op
import sqlalchemy as sa

def upgrade():
    op.add_column('account', sa.Column('last_transaction_date', sa.DateTime))

def downgrade():
    op.drop_column('account', 'last_transaction_date')

Conclusion

Exactly what you see, everything that Django has found out the stack of Django. I didn't write this blogpost to speak ill of Django and Yes to shows that exist other solutions for full development stack. Many people use Django by not understanding the environment with Python, today the Django brings much ready that makes some developers get lazy and not gain skills of software architecture.

Come help with the Bottle, we are a growing community, to contribute with code of Bottle look at the issue that we have open. In case of doubt we have mailing list and IRC channel.

GET INVOLVED

Golang, C and Python the benchmark time

I was wondering how performant Golang is, so I decided to put together a little benchmarking example for myself.

The benchmark will be done in my personal computer:

Processor  3 GHz Intel Core i7
Memory  8 GB 1600 MHz DDR3
Software  OS X 10.9.2 (13C64)

So I started with Python, which is what I know best and created the following simple script;

#!/usr/bin/env python

def fac(n):
    if n == 0:
        return 1
    return n * fac(n - 1)

if __name__ == "__main__":
    t = 0
    for j in range(100000):
        for i in range(8):
            t += fac(i)
    print("total: {0}".format(t))

The reason for the total output, was to have a check to ensure that I was getting the same results in each of the scripts. To make sure that they are doing the same amount of work.

Running the script gives us the following execution time;

$ time python factorial.py

total: 591400000

0.68s user
0.01s system
99% cpu
0.688 total

So I am getting about 1s in total execution time. Not bad.

Now the same code sample in C, to see what the time execution would be;

#include <stdio.h>

int fac(int);

int fac(int n) {
  if (n == 0) {
    return 1;
  }
  return n * fac(n - 1);
}

main() {
  int i, j;
  int t = 0;

  for (j = 0; j < 100000; j++) {
    for (i = 0; i <= 7; i++) {
      t += fac(i);
    }
  }

  printf("total: %d\n", t);
}

Compile and execute the above snippet of code;

$ gcc factorial.c -o factorial
$ time ./factorial

total: 591400000

0.01s user
0.00s system
91% cpu
0.016 total

Ok, that's quite an improvement. This is C, so we do expect there to be a great improvement.

Finally we create our code sample in Go;

package main

import "fmt"

func fact(n int) int {
    if n == 0 {
        return 1
    }
    return n * fact(n-1)
}

func main() {
    t := 0
    for j := 0; j < 100000; j++ {
        for i := range []int{1, 2, 3, 4, 5, 6, 7, 8} {
            t += fact(i)
        }
    }
    fmt.Println("total: ", t)
}

Then build and run the code sample and we get the following;

$ go build factorial.go
$ time ./factorial

total:  591400000

0.01s user
0.00s system
93% cpu
0.018 total

So, that's pretty much the same as C, which is excellent. The best part of it all, is that it is actually fun to code in Go compared to C. Python was always an attraction for me as the language is a breeze to work with and enjoyable programming with it. Go is also a nice language to work with and it's really fast to boot. So I'm very excited about the language.

Corretor Ortográfico no VIM

Desde 2007 escrevo aqui no meu blog, com isso já passei por diversas plataforma de blog (Blogspot, Wordpress, Django, Django Diario, Pelican, entre outras), hoje estou usando liquidluck (ferramenta escrita em Tornado Python para gerar arquivos estático), minha escolha para essa mudança foi simplificar o processo de escrever texto, ou seja, usar o que eu uso no dia a dia para programar, com isso tive algumas perda como corretor ortográfo!

Olhando o LibreOffice achei o plugin chamado VERO – VERificador Ortográfico, e para mim seria excelente ter ele dentro do VIM, pois bem consegui fazer o que eu queria, usar o VERO dentro do VIM.

Instalando o VERO

Primeiro precisamos baixar o plugin VERO (vou criar uma pasta dentro do /var/tmp para deixar centralizado os arquivos) e descompactar

mkdir /var/tmp/vero
cd /var/tmp/vero
wget
http://extensions.libreoffice.org/extension-center/vero-verificador-ortografico-e-hifenizador-em-portugues-do-brasil/pscreleasefolder.2012-01-04.1563120832/2.1/vero_pt_br_v210aoc.oxt
unzip -x vero_pt_br_v210aoc.oxt

Abra o vim e digite:

mkspell pt pt_BR

Precisamos colocar um configuração dentro com seu .vimrc:

echo 'set spell spelllang=pt' >> ~/.vimrc

Precione enter até acabar todas as perguntas e pronto você tem o VERO instalado dentro do seu VIM, agora basta usar o corretor ortográfo!

Veja alguns comando do corretor ortográfico, aqui!

Se você gosta de VIM de uma olhada na configuração que eu mantenho https://github.com/avelino/.vimrc!

A volta dos que nao foram, software livre para sempre

Durante 5 anos usei o sistema operacional da Apple (OS X), o OS X é um ótimo sistema operacional principalmente o ambiente gráfico que é sensassional, sistema de áudio entre outros recursos, os 3 primeiro anos usei sem problema nem um ate que a Apple veio com uma historia de cobrar pelo Xcode (The Xcode interface seamlessly integrates code editing, UI design with Interface Builder, testing, and debugging, all within a single window. The embedded Apple LLVM compiler underlines coding mistakes as you type, and is even smart enough to fix the problems for you automatically), ou seja, é a IDE para escrever projetos para plataforma Apple (OS X e iOS) mais o compilador vugo GCC, essa foi a gota d'agua, eles estavam vendendo o GCC, mas como eu já tinha me acostumado com o ambiente (que não é um trabalho muito complicado pois a Apple faz ótimos produtos) não quiz parar de usar e comprei o Xcode, depois de um tempo a Apple voltou a traz colocando novamente de graça.

Depois dessa dramática historia acima comecei olhar valores de notebook (e ultrabook) a tentativa de parar de usar OS X, logo após olhar valores fica pensando, acho que não vou conseguir voltar usar Linux como estação de trabalho novamente pois vou sentir falta dos aplicativos Apple e deixei a ideia para lá, e nisso se passou mais 1 ano.

Ate que parei para refletir o que eu usava do OS X, segue abaixo a lista de aplicativos:

• iTerm2
• vim (via linha de comando)
• Python
• ssh
• PostgreSQL
• Chrome (e diversos serviços web)

Ou seja, tudo que eu usava e acha que iria sentir falta eu conseguiria rodar em Linux. Logo depois dessa reflexão eu lembrei que tinha ganhado um CR-48 (Chromebook) do Google e resolvi começa brinca com ele para ver como era à experiência, apesar da maquina não ser potente como o Macbook Retina (i7) que eu usava estava atendendo minha necessidade, a primeira vista é um notebook que tem apenas um Chrome e com isso todos os serviços web funciona perfeitamente. Olhando o Chrome OS mais de perto vi que é um Linux (baseado em Gentoo) ao meu ver o Google fez um ótimo trabalho principalmente no ambiente X (mais para frente escrevo um blog post falando sobre o que achei do Chrome OS).

Depois desse lero lero todo, achei uma distribuição Linux que atendia minha necessidade ( browser e console para desenvolver), para quem não sabe é possível instalar Linux via chroot dentro de uma pasta no Chrome OS.

Eis que resolvi compra o Chromebook Pixel, que por sinal tem uma hardware ótimo para trabalhar com Chrome OS.

Estou trabalhando a uma semana no Chrome OS e ate agora não tive necessidade de pegar o Macbook para nada, ou seja, voltei usar Linux e agora posso dizer novamente que não uso nem um software propietario no meu notebook. Tudo que achei que iria sentir falta do ambiente Apple era nada mais nada menos que coisa da minha cabeça.

Estou de volta ao desktop livre.