Liste de taskuri

Nu-mi plac notitele post-it. Am nevoie de o modalitate de a organiza listele de sarcini care trebuie rezolvate până la o anumită dată.

Am dat de tadalist.com. Care pare să rezolve elegant problema.

Toolkit-uri pentru JavaScript

După ceva săpături, am dat de mootools şi transcorners.

Django şi Vim

Am dat de o pagină foarte interesantă,
http://code.djangoproject.com/wiki/UsingVimWithDjango

pe care sunt descrise nişte scripturi Vim care ajută la lucrul cu Django.

Cele mai interesant chestii mi s-au părut XMLedit şi fişierele de syntax highlighting pentru template-uri Django.

Metaprogramming în Python - pentru incepători

Căutând o modalitate de a specifica repede structuri în Python am căutat pe net o modalitate de a crea automat clasele cu structuri (genul de clasă care arată cam aşa):

class Point(object):
  def __init__(self, x, y):
      self.x = x
      self.y = y
  def __repr__(self):
      return "(%f, %f)" % (self.x, self.y)

Din nou cunoştinţele de Lisp s-au dovedit foarte folositoare (deşi indirect). Căutând pe Google "python defstruct" (defstruct este macro-ul Lisp care creează codul pentru astfel de structuri) am dat de:

http://mail.python.org/pipermail/python-list/2001-October/109140.html

unde un suflet milostiv a publicat un exemplu simplu şi util de metaprogramare în Python.

am modificat puţin codul şi am obţinut:

def defstruct(name, *fields):
    class Struct(object):
        def __init__(self, *contents):
            if len(contents) != len(self.structfields):
                raise TypeError, (
                    "wrong number of arguments: expected %d %s, got %d" %
                    (len(self.structfields),
                     repr(self.structfields),
                     len(contents)))
            for fieldnum in range(len(contents)):
                setattr(self, 
                        self.structfields[fieldnum], 
                        contents[fieldnum])
        def __repr__(self):
            args = ", ".join([str(getattr(self, f)) for f in fields])
            return "%s(%s)" % (name, args)
    Struct.structfields = fields
    return Struct  

cu exemplul de utilizare:

if __name__ == "__main__":
    Point = defstruct('Point', 'x', 'y')
    p1 = Point(1, 20)
    p2 = Point(-4, 34)
    print p1
    print p2

SSH fără parolă de fiecare dată

E agasant să introduc parola de SSH de fiecare dată când mă leg la un server.

Se poate autentificare fără parolă? Normal că se poate. Iaca instrucţiuni:

• http://www.csua.berkeley.edu/~ranga/notes/ssh_nopass.html (Cu menţiunea că ssh-keygen ar trebui invocat cu opţiunea -t)
• http://www.astro.caltech.edu/~mbonati/WIRC/manual/DATARED/setting_up_no-password_ssh.html

Detalii Django

Un amănunt care nu e foarte bine documentat în Django: cum să adaug validări custom pentru situl de admin generat automat:

Folosesc pentru *Field argumentul validator_list din constructor. Există validatori predefiniţi în django.core.validators, precum şi documentaţie - se referă la formele vechi, dar nu cred că va dispărea acest mic detaliu aşa uşor.

Am aflat că se poate folosi validator_list aici dintr-o discuţie google groups.

Exemplu de utilizare:

from django.db import models
from django.core.validators import isUpperCase

# Create your models here.

# adresa hotelului sau amploiatului
class Address(models.Model):
    country = models.CharField(maxlength = 150,
            validator_list = [isUpperCase])
    town = models.CharField(maxlength = 150)
    street = models.CharField(maxlength = 150)
    number = models.CharField(maxlength = 50)
    def __str__(self):
        return "%s, %s (%s, %s)" % \
                (self.street, self.number, self.town, self.country)
    class Meta:
        verbose_name_plural = "Adresses"
    class Admin:
        pass

How To Design a Good API & Why It Matters

http://www.infoq.com/presentations/effective-api-design

Prezentare foarte mişto a lui Joshua Bloch (ex-Sun, acum la Google) despre cum se "gândeşte" un API.

Tema este mai larg-aplicabilă decât pare la prima vedere, pentru că de fapt de fiecare dată când scriem metodele publice ale unei clase proiectăm un API. De fiecare dată când scriem un grup de clase care se vor folosi împreună proiectăm un API.

"Effective Java", tot a lui Joshua Bloch, este scrisă din aceeaşi perspectivă. Aceeaşi carte.