I started playing around with s3cmd command line utility and I realize that is really powerful so, I decide to write my own scripts to be able to backup automatically all the important files of my servers to the cheaper and easy to use Amazon S3 service.

The whole system is based on two bash scripts, the crontab and a few extra applications like 7zip and s3cmd. I will explain step by step how I build up the system and at the end I’ll provide the full code of the scripts.

Requirements

The first step is to be sure that you have installed the 7zip and s3cmd tools, in my case I’m using ubuntu so, for me the command to install the tools is:

sudo apt-get install p7zip s3cmd

Basic setup

Now we can follow with the basic setup, I created a folder in the root of the filesystem called backups, the inside this folder I create serveral folders, at the end the structure is like follow:

/backups
    /compressed
    /data
        /db
        /svn
        /www
    /scripts

The compressed folder is used at the end of the script to compress all the files to one .7z file, in the data folder we will copy the information we want to backup and in the scripts folder we will store as it’s name says the two scripts we will use.

Backup script

Now, let’s have a look at those scripts. The first one is to do the backup, in my case I’m doing a backup of the subversion, mysql and files under /var/www.

The script starts with the following block:

echo `date '+%F %T'`: Starting the backup

#Dumping the repos
echo `date '+%F %T'`: Starting the dump of the repos
for i in /user/local/svn/*/; do
    repo=`basename $i`
    echo `date '+%F %T'`: Dumping repo $repo
    /usr/bin/svnadmin dump /usr/local/svn/$repo > /backups/data/svn/$repo.dump
    echo `date '+%F %T'`: Repo $repo dumped
done

We suppose that the svn folder is located at /usr/local/svn, basically here we are going through each folder inside /usr/local/svn/ and we call svnadmin dump to dump that repository in one file, that file is stored in /backups/data/svn/.

#Dumping the DB
echo `date '+%F %T'`: Starting the dump of the DataBases
for i in /var/lib/mysql/*/; do
    db=`basename $i`
    echo `date '+%F %T'`: Dumping DB $db
    /usr/bin/mysqldump -uroot -p$db_password $db > /backups/data/db/$db.sql
    echo `date '+%F %T'`: Database $db dumped
done

In this second block we are doing more or less the same thing, we are going through each folder on /var/lib/mysql/ and calling mysqldump to export each DB in one file stored at /backups/data/db/.

#Copy all the websites
echo `date '+%F %T'`: Starting the dump of websites
for i in /var/www/*/; do
    site=`basename $i`
    echo `date '+%F %T'`: Dumping site $site
    /usr/bin/7z a -mx6 -t7z /backups/data/www/$site.7z -p$compression_password /var/www/$site
    echo `date '+%F %T'`: Site $site dumped
done

In the third block we are dumping the websites, I have the websites stored at /var/www folder and each site is inside a folder with the domain as folder name. Basically we are doing the same, loop through /var/www/ and compressing each site individually in a .7z file with a compression level of 6 and secured with a password.
I store each site in a separate file because if I have to restore a site I don’t need to uncompress all the sites, just the main file and then the compressed site.
I was playing with different compression levels and 6 is the most suitable to maintain a good compression ratio without wasting a lot of time.

#Compressing all the data
echo `date '+%F %T'`: Compressing the info
filename=$(date +%Y%m%d)
/usr/bin/7z a -mx6 -t7z /backups/compressed/$filename.7z -p$password /backups/data/*
echo `date '+%F %T'`: Info compressed

Now with all the information we want to backup in place we will compress all together in one single file, that’s the purpose of this block of code, the final filename is a timestamp of today using the date command.

#Upload to Amazon S3
echo `date '+%F %T'`: Uploading to Amazon S3
/usr/bin/s3cmd put --no-progress /backups/compressed/$filename.7z s3://BUCKET_NAME/$filename.7z
echo `date '+%F %T'`: Upload completed

Ok, we have the compressed file and one of the final steps is upload this file to Amazon S3. For that task we are using the s3cmd tool passing the parameter –no-progress to avoid an “interactive” output of the upload status.

#Delete the local backups
echo `date '+%F %T'`: Cleaning up
rm -Rf /backups/data/svn/*
rm -Rf /backups/data/db/*
rm -Rf /backups/data/www/*
rm -Rf /backups/compressed/*
echo `date '+%F %T'`: Clean completed
echo `date '+%F %T'`: Backup completed

And the final block of code is just a clean up, after the upload to amazon we delete all the files we have generated inside the /backups folder.

Ok, seems complex but is pretty strightforward, also if you take a look you’ll see that all the messages contains a timestamp, with that information we are able to determine how many time we spend in each task.
One disadvantage of this script is that we are not checking if the file was uploaded correctly to Amazon, maybe this will be a future improvement.

Maintenance script

Now let’s take a look at the other script, the purpose is just delete old backups based on a timestamp, in my case we’re storing the backups for one month, it’s very affordable with the Amazon prices.

for filename in `s3cmd ls s3://$bucket`; do
    if [[ $filename =~ ([0-9]*)\.7z ]]; then
        timestamp=${BASH_REMATCH[1]}
        echo `date '+%F %T'` - Reading metadata of: $filename
        echo -e "\tFilename: $filename"
        echo -e "\tTimestamp: $timestamp"
        if [[ $timestamp -le $limit ]]; then
            let "total=total+1"
            echo -e "\tResult: Backup deleted\n"
            /usr/bin/s3cmd del $filename
        else
            echo -e "\tResult: Backup keeped\n"
        fi
    fi
done

This is the only code block we have in the maintenance script, the idea is to retrieve the list of files we have in the bucket with s3cmd, then we check if the gived part contains the pattern ([0-9]*)\.7z (because the command s3cmd ls gives more information rather than just the filenames).
If we detect a segment that matches the regex we get the filename without the extension (the timestamp of the backup), and we check in this case if the timestamp is older than one month (the timestamp of one month ago is stored in the $limit variable). If the backup is older we remove it calling the s3cmd del command.

If you need to store the files more time just change the $limit variable and that’s it.

Wow, seems a large process, ok, now let’s have a look at the last step to let this work, the cronjobs.
I created to cronjobs and redirected the output of them to the stdout because I want to receive an email after the backup, my crontab look like this:

# m h  dom mon dow   command
MAILTO=YOUR_EMAIL_ADDRESS_HERE
00 22 * * * /backups/scripts/s3backup 2>&1
00 23 * * * /backups/scripts/s3backup-maintenance 2>&1

Just put there the values you want to run the crons and don’t forget to put at the end 2>&1.

Conclusion

With this system you’ll have your backups in a safe and cheap place without headaches and with a full report in you email every time the script runs. For sure these scripts can be impoved with a few checks and you can extend it to fit your needs.
I hope you have enjoyed this HowTo and begin to use this scripts! For sure improvements are welcomed, don’t hesitate to comment!.

Source code

Grab the full source code of the backup script and the maintenance script.

En este tutorial vamos a ver como instalar el servidor de subversion en una maquina ubuntu.

Para ello el primer paso es instalar los paquetes necesarios

sudo apt-get install subversion libapache2-svn subversion-tools

Creamos la carpeta para guardar los ficheros

sudo mkdir /home/<user>/svn

Editamos el fichero de configuración

sudo nano /etc/apache2/mods-enabled/dav_svn.conf

Hay que modificar el archivo hasta que se parezca a esto

# dav_svn.conf - Example Subversion/Apache configuration
#
# For details and further options see the Apache user manual and
# the Subversion book.# <location URL> ... </location>
# URL controls how the repository appears to the outside world.
# In this example clients access the repository as http://hostname/svn/
<location /svn>
# Uncomment this to enable the repository,
DAV svn
# Set this to the path to your repository
SVNParentPath /home/<user>/svn

# The following allows for basic http authentication.  Basic authentication
# should not be considered secure for any particularly rigorous definition of
# secure.
# to create a passwd file
# # rm -f /etc/apache2/dav_svn.passwd
# # htpasswd2 -c /etc/apache2/dav_svn.passwd dwhedon
# New password:
# Re-type new password:
# Adding password for user dwhedon
# #
# Uncomment the following 3 lines to enable Basic Authentication
 AuthType Basic
 AuthName "Subversion Repository Access"
 AuthUserFile /etc/apache2/dav_svn.passwd
 Require valid-user
# Uncomment the following line to enable Authz Authentication
# AuthzSVNAccessFile /etc/apache2/dav_svn.authz
# The following three lines allow anonymous read, but make
# committers authenticate themselves.
#<limitexcept GET PROPFIND OPTIONS REPORT>
#Require valid-user
#</limitexcept>
</location>

Creamos el fichero de usuarios y claves

sudo htpasswd -cm /etc/apache2/dav_svn.passwd <username>

Usamos este comando si queremos añadir mas usuarios

sudo htpasswd /etc/apache2/dav_svn.passwd <another username>

Reiniciamos apache

sudo /etc/init.d/apache2 restart

Creamos la carpeta que contendrá el proyecto

sudo mkdir -p /home/<user>/svn/<project>

Creamos el repositorio

sudo svnadmin create /home/<user>/svn/<project>

Conectamos al subversion localmente y creamos las carpetas Trunk, Tags y Branches

sudo svn mkdir file:///home/<user>/svn/<project>/trunk -m "Trunk"
sudo svn mkdir file:///home/<user>/svn/<project>/tags -m "Tags"
sudo svn mkdir file:///home/<user>/svn/<project>/branches -m "Branches"

Otorgamos permisos a apache

sudo chown -R www-data.www-data /home/<user>/svn

Navegamos a la carpeta /etc/init.d, creamos un fichero llamado init-svnserve y lo abrimos con nano para editarlo

cd /etc/init.d/
sudo touch init-svnserve
sudo nano init-svnserve

En el fichero añadimos esta linea

svnserve -d -r /home/<user>/svn

Damos permisos de ejecución al fichero

sudo chmod +x init-svnserve

Actualizamos el arranque del sistema para que detecte el nuevo fichero

sudo update-rc.d init-svnserve defaults

Reiniciamos el servidor y todo funcionando!

sudo shutdown -r now

• Ubuntu Software Center →Substituye a la aplicación “Agregar y quitar” del menú Aplicaciones.
• Gnome 2.28 → Nueva versión del entorno de escritorio.
• Empathy → El cliente de mensajería Empathy substituye a Pidgin.
• Quickly → Permite a los desarrolladores más facilidades para la creación de aplicaciones en Ubuntu y compartir los archivos a través de paquetes .deb entre otros.
• Kernel → 2.6.31-14.48 kernel basado en 2.6.31.1.
• Grub 2 → El gestor de arranque substituye a Grub Legacy. Sólo podremos hacer uso de él desde Karmic Koala y no podremos actualizar desde otras versiones al tratarse de una operación arriesgada.
• Ubuntu One → 2Gb de almacenamiento gratuito online y la facilidad de compartir archivos ya sea con ordenadores propios o con los de otros. Por un precio a bajo costo podemos ampliar esta capacidad.

Para más información acerca del Ubuntu 9.10 ir a: http://www.ubuntu.com/products/whatisubuntu/910features

Podemos obtener Ubuntu desde: http://www.ubuntu.com/getubuntu

En primer lugar nuestra clase ciudadano va a necesitar guardar dos valores referentes al ciudadano al que representa, el primer dato será el material genético a guardar y el segundo caso el fitness actual del ciudadano, para ello emplearemos dos variables privadas ya que queremos controlar exactamente que se almacena en estas variables. Por lo tanto para poder manipular y ver estos datos vamos a necesitar los respectivos setters/getters.

Por último necesitaremos crear una función para calcular el fitness del ciudadano.

El fitness va muy ligado al problema a resolver, en nuestro caso como estamos desarrollando un Hello World el algoritmo va a tratar de llegar a una string objetivo a partir de una string aleatoria, con lo cuál una buena función de fitness debe atorgar una puntuación mas alta o baja dependiendo de lo cerca que estemos del objetivo. En mi caso voy a calcular la distancia entre las letras de la cadena objetivo y la cadena del ciudadano actual.

Atención, no me estoy refiriendo a la distancia Levenshtein. La distancia Levenshtein es el número mínimo de operaciones requeridas para transformar la cadena A en la cadena B, por ejemplo si tenemos la cadena “Manzana” y queremos conseguir “Manzanas” la distancia Levenshtein será 1.

Nuestra función de fitness para calcular lo bueno que es nuestro ciudadanos  va a sumar la diferencia carácter a carácter entre la string objetivo y la string actual a partir del número correspondiente ASCII de los caracteres. Es decir, entre la letra “A” (número 65 en la tabla ASCII) y la letra “P” (número 80 en la tabla ASCII) nuestra función debería retornar el número 15. Por lo tanto si tenemos la cadena “Manzana” y la cadena “Manzano” nuestra función retornará 14.

Cabe destacar que para que el algoritmo funcione correctamente hay que establecer unas cuantas limitaciones, de momento debemos establecer que las strings siempre van a ser del mismo tamaño, es decir en el momento de comparar las strings en nuestra función de fitness vamos a suponer que las strings miden lo mismo.

Por otra parte también quiero hacer notar que en el constructor de la clase inicializamos los datos de las variables, el fitness a -1 y el string a vacío.

Sin mas dilaciones aquí os dejo el código completo de nuestra clase Citizen.

<?php

class Citizen{

 private $data;
 private $fitness;

 public function __construct(){
   $this->data = '';
   $this->fitness = -1;
 }

 public function getData(){
   return $this->data;
 }

 public function setData($newData = NULL){
   try{
     if(!is_null($newData)){
     $this->data = $newData;
     }
   }catch(Exception $e){
     die($e->getMessage());
   }
 }

 public function getFitness(){
   return $this->fitness;
 }

 public function setFitness($newFitness = NULL){
   try{
     if(!is_null($newFitness)){
     $this->fitness = $newFitness;
     }
   }catch(Exception $e){
     die($e->getMessage());
   }

 }

 public function calculateFitness($objective = NULL){
   try{
     if(is_null($objective)){
       throw new Exception('Error, no se ha especificado objetivo');
     }

     $fitness = 0;
     for($x=0;$x<strlen($objective);$x++){
       $fitness += abs(ord($objective[$x]) - ord($this->data[$x]));
     }

     $this->setFitness($fitness);
   }catch(Exception $e){
     die($e->getMessage());
   }

 }

}

?>

Los algoritmos genéticos o GA se utilizan básicamente para realizar búsquedas en un espacio de soluciones amplias y con muchos máximos y mínimos locales, generalmente en funciones no derivables o de derivación muy compleja. Cabe destacar que el hecho de utilizar un GA no implica hallar la solución óptima puesto que la búsqueda puede converger prematuramente en un mínimo o máximo local y no poder encontrar el máximo/mínimo general.

Algunos ejemplos de uso de este tipo de algoritmos son:

• Diseño automatizado de sistemas de comercio en el sector financiero.
• Optimización de carga de contenedores.
• Diseño de topologías de circuitos impresos.
• Aprendizaje de comportamiento de robots.
• Infraestructura de redes de comunicaciones móviles.
• Predicción.
• Aplicaciones en planificación de procesos industriales.
• Construcción de horarios en grandes universidades, evitando conflictos de clases.
• Optimización de producción y distribución de energía eléctrica.

Los GA se inspiran en la evolución biológica para realizar la búsqueda creando una analogía entre el conjunto de soluciones de un problema, llamado fenotipo, y el conjunto de individuos de una población natural, codificando la solución del problema en forma binaria, u otro tipo de codificación, en una cadena llamada cromosoma. Cada símbolo que conforma el cromosoma es un gen.

La búsqueda de la solución óptima del problema se realiza mediante iteraciones llamadas generaciones, en cada generación se realiza una serie de operaciones sobre los cromosomas o ciudadanos de la población.

Ahora vamos a ver el proceso que sigue un algoritmo genético para buscar una solución:

1. Generamos aleatoriamente los ciudadanos (cromosomas) que van a conformar nuestra población inicial.
2. Realizamos una evaluación (fitness) de los ciudadanos para saber que tan “buena” es la solución.
3. Verificamos si debemos acabar la ejecución del algoritmo ya sea mediante el número máximo de generaciones o habiendo encontrado la solución óptima ya sea con tolerancia o no.
4. Una vez conocemos la calidad de nuestros ciudadanos seleccionamos a los mejores para reproducirlos.
5. Aplicamos operadores genéticos ya sea el de cruzamiento u otros para reproducir a los mejores ciudadanos y obtener descendencia de estos.
6. Aplicamos operadores de mutación para ampliar la zona de búsqueda no cubierta por los ciudadanos actuales.
7. Reemplazamos la generación actual con la descendencia recién obtenida de los mejores ciudadanos.

El proceso se repite ejecutando los pasos del 2 al 7 hasta encontrar la solución o llegar al máximo de generaciones. A modo de apunte cabe destacar que hay diferentes métodos de selección tales como el elitismo, la ruleta de selección, etc. Por otra parte también existen diferentes métodos de reproducción tales como crossover sexual, asexual, etc.

Más adelante y para no hacer más denso este post,  explicaré detalladamente cada punto de los vistos aquí.

Una vez visto esto y con una pequeña idea del funcionamiento de los GA construiremos nuestro GA Hello World, para ello utilizaremos PHP (la explicación es extensible a otros lenguajes tales como C) ya que al ser interpretado nos permitirá cambiar valores sin necesidad de recompilar el GA cada dos por tres. La programación de este GA esta realizada mediante POO con lo cuál el próximo post se basará en crear la primera clase necesaria que representará al cromosoma o ciudadano.

Evidentemente cuando un GA se va a utilizar en alguna aplicación se desarrolla en un lenguaje que se pueda compilar para ganar velocidad y minimizar los recursos ya sea C, C++, Java, etc.

Nano es un editor de ficheros por terminal, nos puede ser muy util sobretodo si tenemos que editar ficheros en un servidor o maquina remota mediante una conexión SSH. Aparentemente puede parecer muy sencillo pero tiene algunas características que lo hacen muy potente como las búsquedas por expresiones regulares, coloreado de sintaxis, etc.

Actualmente nano viene instalado o se puede instalar en aquellos sistemas operativos que son compatibles con UNIX como Linux, BSD o MacOS X incluso existe en la web oficial una versión para Windows utilizando las herramientas Cygwin. En principio suele venir ya pre-instalado, como es el caso de MacOS X o Ubuntu Desktop pero en otros sistemas operativos como Ubuntu server será necesario instalarlo desde el terminal o algún programa de gestión de paquetes.

Cómo instalar Nano

Para instalar nano desde el terminal en sistemas Debian basta con ejecutar este comando:

sudo apt-get install nano

Como he comentado antes en el sistema operativo MacOS X nano ya viene pre-instalado así que no hará falta hacer nada para tenerlo.

Configuración de nano

La configuración de nano es extremadamente sencilla, solo debemos editar un fichero de configuración. La ruta a este fichero puede variar dependiendo del sistema operativo, en el caso de Ubuntu y MacOS X lo podremos encontrar en /etc/nanorc.

Para proceder a editarlo podemos ejecutar este comando en el terminal:

sudo nano /etc/nanorc

Básicamente nos encontraremos con tres casos, el primero es que no exista el fichero con lo cuál lo crearemos, el segundo caso es que el fichero este vacío y el último caso es que el fichero venga con contenido por defecto. En este último caso solo tendremos que ir descomentando las líneas que nos interesen, en los otros dos casos simplemente escribimos las líneas de configuración que queremos utilizar.

Aquí debajo podremos encontrar una muestra de cómo puede ser el fichero nanorc.

## Sample initialization file for GNU nano.
##
## Please note that you must have configured nano with --enable-nanorc
## for this file to be read!  Also note that this file should not be in
## DOS or Mac format, and that characters specially interpreted by the
## shell should not be escaped here.
##
## To make sure a value is disabled, use "unset ".
##
## For the options that take parameters, the default value is given.
## Other options are unset by default.
##
## Quotes inside string parameters don't have to be escaped with
## backslashes.  The last double quote in the string will be treated as
## its end.  For example, for the "brackets" option, ""')>]}" will match
## ", ', ), >, ], and }.

## Use auto-indentation.
# set autoindent

## Backup files to filename~.
# set backup

## The directory to put unique backup files in.
# set backupdir ""

## Do backwards searches by default.
# set backwards

## Use bold text instead of reverse video text.
# set boldtext

## The characters treated as closing brackets when justifying
## paragraphs.  They cannot contain blank characters.  Only closing
## punctuation, optionally followed by closing brackets, can end
## sentences.
##
# set brackets ""')>]}"

## Do case sensitive searches by default.
# set casesensitive

## Constantly display the cursor position in the statusbar.  Note that
## this overrides "quickblank".
# set const

## Use cut to end of line by default.
# set cut

## Set the line length for wrapping text and justifying paragraphs.
## If fill is 0 or less, the line length will be the screen width less
## this number.
##
# set fill -8

## Enable ~/.nano_history for saving and reading search/replace strings.
# set historylog

## The opening and closing brackets that can be found by bracket
## searches.  They cannot contain blank characters.  The former set must
## come before the latter set, and both must be in the same order.
##
# set matchbrackets "(< [{)>]}"

## Use the blank line below the titlebar as extra editing space.
# set morespace

## Enable mouse support, if available for your system.  When enabled,
## mouse clicks can be used to place the cursor, set the mark (with a
## double click), and execute shortcuts.  The mouse will work in the X
## Window System, and on the console when gpm is running.
##
# set mouse

## Allow multiple file buffers (inserting a file will put it into a
## separate buffer).  You must have configured with --enable-multibuffer
## for this to work.
##
# set multibuffer

## Don't convert files from DOS/Mac format.
# set noconvert

## Don't follow symlinks when writing files.
# set nofollow

## Don't display the helpful shortcut lists at the bottom of the screen.
# set nohelp

## Don't add newlines to the ends of files.
# set nonewlines

## Don't wrap text at all.
# set nowrap

## Set operating directory.  nano will not read or write files outside
## this directory and its subdirectories.  Also, the current directory
## is changed to here, so any files are inserted from this dir.  A blank
## string means the operating directory feature is turned off.
##
# set operatingdir ""

## Preserve the XON and XOFF keys (^Q and ^S).
# set preserve

## The characters treated as closing punctuation when justifying
## paragraphs.  They cannot contain blank characters.  Only closing
## punctuation, optionally followed by closing brackets, can end
## sentences.
##
# set punct "!.?"

## Do quick statusbar blanking.  Statusbar messages will disappear after
## 1 keystroke instead of 26.  Note that "const" overrides this.
##
# set quickblank

## The email-quote string, used to justify email-quoted paragraphs.
## This is an extended regular expression if your system supports them,
## otherwise a literal string.  Default:
# set quotestr "^([     ]*[#:>\|}])+"
## if you have extended regular expression support, otherwise:
# set quotestr "> "

## Fix Backspace/Delete confusion problem.
# set rebinddelete

## Fix numeric keypad key confusion problem.
# set rebindkeypad

## Do extended regular expression searches by default.
# set regexp

## Make the Home key smarter.  When Home is pressed anywhere but at the
## very beginning of non-whitespace characters on a line, the cursor
## will jump to that beginning (either forwards or backwards).  If the
## cursor is already at that position, it will jump to the true
## beginning of the line.
# set smarthome

## Use smooth scrolling as the default.
# set smooth

## Use this spelling checker instead of the internal one.  This option
## does not properly have a default value.
##
# set speller "aspell -x -c"

## Allow nano to be suspended.
# set suspend

## Use this tab size instead of the default; it must be greater than 0.
# set tabsize 8

## Convert typed tabs to spaces.
# set tabstospaces

## Save automatically on exit, don't prompt.
# set tempfile

## Disallow file modification.  Why would you want this in an rcfile? 
# set view

## The two single-column characters used to display the first characters
## of tabs and spaces.  187 in ISO 8859-1 (0000BB in Unicode) and 183 in
## ISO-8859-1 (0000B7 in Unicode) seem to be good values for these.
# set whitespace "  "

## Detect word boundaries more accurately by treating punctuation
## characters as parts of words.
# set wordbounds

## Color setup
##
## Format:
##
## syntax "short description" ["filename regex" ...]
##
## The "none" syntax is reserved; specifying it on the command line is
## the same as not having a syntax at all.  The "default" syntax is
## special: it takes no filename regexes, and applies to files that
## don't match any other syntax's filename regexes.
##
## color foreground,background "regex" ["regex"...]
## or
## icolor foreground,background "regex" ["regex"...]
##
## "color" will do case sensitive matches, while "icolor" will do case
## insensitive matches.
##
## Valid colors: white, black, red, blue, green, yellow, magenta, cyan.
## For foreground colors, you may use the prefix "bright" to get a
## stronger highlight.
##
## To use multi-line regexes, use the start="regex" end="regex"
## [start="regex" end="regex"...] format.
##
## If your system supports transparency, not specifying a background
## color will use a transparent color.  If you don't want this, be sure
## to set the background color to black or white.
##
## If you wish, you may put your syntaxes in separate files.  You can
## make use of such files (which can only include "syntax", "color", and
## "icolor" commands) as follows:
##
## include "/path/to/syntax_file.nanorc"
##
## Unless otherwise noted, the name of the syntax file (without the
## ".nanorc" extension) should be the same as the "short description"
## name inside that file.  These names are kept fairly short to make
## them easier to remember and faster to type using nano's -Y option.
##
## All regexes should be extended regular expressions.

## Key bindings
## Please see nanorc(5) for more details on this
##
## Here are some samples to get you going
##
# bind M-W nowrap main
# bind M-A casesens search
# bind ^S research main

## Set this if your backspace key sends delete most of the time (2.1.3+)
# bind kdel backspace all

## Nanorc files
# include "@PKGDATADIR@/nanorc.nanorc"

## C/C++
# include "@PKGDATADIR@/c.nanorc"

## Cascading Style Sheets
# include "@PKGDATADIR@/css.nanorc"

## Debian files
# include "@PKGDATADIR@/debian.nanorc"

## Gentoo files
# include "@PKGDATADIR@/gentoo.nanorc"

## HTML
# include "@PKGDATADIR@/html.nanorc"

## PHP
# include "@PKGDATADIR@/php.nanorc"

## TCL
# include "@PKGDATADIR@/tcl.nanorc"

## TeX
# include "@PKGDATADIR@/tex.nanorc"

## Quoted emails (under e.g. mutt)
# include "@PKGDATADIR@/mutt.nanorc"

## Patch files
# include "@PKGDATADIR@/patch.nanorc"

## Manpages
# include "@PKGDATADIR@/man.nanorc"

## Groff
# include "@PKGDATADIR@/groff.nanorc"

## Perl
# include "@PKGDATADIR@/perl.nanorc"

## Python
# include "@PKGDATADIR@/python.nanorc"

## Ruby
# include "@PKGDATADIR@/ruby.nanorc"

## Java
# include "@PKGDATADIR@/java.nanorc"

## AWK
# include "@PKGDATADIR@/awk.nanorc"

## Assembler
# include "@PKGDATADIR@/asm.nanorc"

## Bourne shell scripts
# include "@PKGDATADIR@/sh.nanorc"

## POV-Ray
# include "@PKGDATADIR@/pov.nanorc"

## XML-type files
# include "@PKGDATADIR@/xml.nanorc"

Básicamente las líneas que deberíamos descomentar son las siguientes:

set const (Esta funcionalidad muestra constantemente la posición del cursor file/columna en el cuadro de abajo)
set mouse (Habilita el uso del ratón para poder seleccionar texto, pegarlo y demás)
set rebinddelete (Configura el botón de borrar como acción borrar y no suprimir como puede venir en algunos sistemas)
set smooth (Mejora el salto del texto al hacer scroll)
set tabsize 2 (Especificamos el numero de columnas que va a ocupar una tabulación)
set tabstospaces (Especificamos que el programa debe utilizar espacios en lugar de tabulaciones, muy útil si modificamosficheros YAML)

Y además también descomentamos todos los includes que hay al final del fichero (solo en sistemas linux, no sirve en MacOS X) para poder activar el coloreado del texto dependiendo del tipo de fichero. Como podréis comprobar la línea set tabsize 2 es la línea set tabsize 8 en el fichero de arriba, además de descomentarla le hemos modificado el tamaño de 8 a 2.

Una vez realizados todos estos cambios pulsamos las teclas Ctrl+X escribirmos “Y” y pulsamos Enter.

Ahora al abrir un fichero ANSI C por ejemplo podremos ver que nos muestra algo similar a esto.

Fichero ANSI C abierto en nano después de configurarlo

Subversion es un software open source, para el trabajo en equipo, que consiste en un sistema de control de versiones. Los usuarios conectados a internet o a una red local pueden participar intercambiando modificaciones de los archivos. Todas las modificaciones se guardan en un servidor común creando un historial de todos los cambios por lo que nos permite recuperar cualquier versión si nos equivocamos. Cuando un usuario realiza una modificación sólo tiene que subirla para que el resto de usuarios puedan descargar la nueva información.

Podéis descargar Subversion en http://subversion.tigris.org/

Aquí os dejamos una lista de los comandos más utilizados:

Descargar un proyecto:

En primer lugar nos situamos en el directorio dónde vayamos a descargar el proyecto (cd directorio) y escribimos:

svn checkout https://servidorsvn/ruta/proyecto

*Podemos escribir co en lugar de commit.
Actualizar una copia en local:

Para descargarnos la última versión escribimos:

svn update

Si sólo queremos actualizar un directorio:

svn -N update

Si queremos actualizar un fichero:

svn update fichero

Si queremos actualizar una determinada versión:

svn update -r número_de_versión

*Podemos escribir up en lugar de update.

Subir modificaciones al servidor:

Para subir los cambios que hayamos realizado al servidor debemos escribir:

svn commit -m "Explicación_de_los_cambios_realizados"

*Podemos escribir ci en lugar de commit.

Eliminar, añadir y mover un directorio o fichero:

svn remove fichero_o_directorio

*Podemos escribir rm en lugar de remove.

Añadir un fichero o un directorio:

svn add directorio

Si queremos añadir también los subdirectorios escribimos:

svn add -R directorio

Si queremos mover un fichero o directorio escribimos:

svn move fichero_de_origen fichero_de_destino

Mostrar ayuda general de Subversion:

svn help

Comprobar el estado de la copia en local:

svn status

Este comando nos mostrará por ejemplo qué archivos falta añadir, si han sido modificados localmente, eliminados o si existe algún conflicto.

Más información en:

http://subversion.tigris.org/

http://es.wikipedia.org/wiki/Subversion

Superordenador CRAY CX

Los puntos que destaca Microsoft sobre este nuevo Windows es que no necesitará un ordenador del estilo CRAY para funcionar, es decir, “supuestamente” en un PC normalito debería correr perfectamente y que han solucionado la gran mayoría de incompatibilidades que presenta Vista con el hardware de otros fabricantes, para ello han inventado el Windows XP Mode.

El Windows XP mode permite arrancar el ordenador con Windows XP, según ellos, una máquina virtual completa. Este modo estará disponible preinstalado en las versiones más profesionales (y más caras, evidentemente) o mediante descarga desde su web.

Windows 7 ha heredado de su hermano menor Vista la plataforma e implementaciones de seguridad que, según Microsoft, fué el mayor avance conseguido hasta el momento (cuestionable por muchos otros).

Barra de tareas al mas puro estilo KDE

Entre las nuevas funcionalidades y mejoras también podemos encontrar una barra de tareas más grande, a algunos os recordará al entorno KDE, así como una lista de acciones más frecuentes. Han implementado esquinas activas al puro estilo Macintosh, si ponemos el ratón en la esquina inferior derecha las ventanas que tengamos abiertas se volverán transparentes dejando a la vista el escritorio. Windows Search está más integrado en el sistema y consume menos recursos, con él podremos buscar dentro de documentos, correos electrónicos, etc. Windows 7 también integra por defecto Internet Explorer 8 que, según ellos, se podrá desinstalar completamente (yo hasta que no lo vea no me lo creo)… También han mejorado el panel de control consiguiendo una mejor integración del centro de impresión y del administrador de dispositivos. Por otra parte han integrado toda una tecnología al mismísimo estilo iPhone.

Antes de usar las esquinas activas

Usando las esquinas activas

Como podemos observar Microsoft hace esfuerzos por ponerse a la altura del mercado, tanto iPhone como Macintosh y Linux han revolucionado el mercado e instaurado nuevas funcionalidades que para muchos ya son imprescindibles, como las esquinas activas, y evidentemente en el mundo de la informática o te pones al día o pierdes muchos usuarios.

A mi manera de ver Microsoft debe mejorar muchísimos aspectos en sus sistemas operativos, la política que ha adoptado de lanzar nuevas versiones tan diferentes entre ellas hace pensar en la cantidad de fallos que se habrán cometido en el proceso y quizás debería implementar procesos menos cambiantes, es decir, sacar una versión del sistema operativo e ir actualizándolo y mejorándolo (tal y como hace Apple o algunas distribuciones como Ubuntu) en lugar de crear uno totalmente nuevo cada vez.

Según los rumores que rondan por internet Windows podría tener fecha de caducidad debido a la dificultad que están teniendo al adaptarse a los nuevos tiempos y que Windows ya no es capaz de afrontar con solvencia los nuevos retos de la sociedad de la información. El nuevo sistema operativo que sustituiría a Windows se llamaría Midori y funcionaría de una manera virtualizada.

Si queréis descargar la RC de Windows 7 podéis ir a la web oficial.

El 23 de Abril nace un nuevo Ubuntu la versión 9.04 Jaunty Jackalope con muchas mejoras respecto a su antecesor Intrepid Ibex.

De momento podemos descargarnos la versión Release Candidate.

Las mejoras más considerables en esta RC según la web de Ubuntu son:

• El entorno de escritorio GNOME 2.26 que incluye la novedad del todo en uno en grabración de CD (Brasero) y las mejorías en la manipulación de multiples monitores (actualización de Gnome-display-properties).
• La versión 1.6 X.Org Server.
• Wacom tablet hotplugin (se activa automáticamente cuando está conectado ya no necesita modificación en xorg.conf.
• Nuevo estilo para las notificaciones y para las preferencias de las notificaciones. Mira el vídeo demostrativo que ofrece la web de Ubuntu.
• Mejor rendimiento de arranque.
• Linux Kernel 2.6.28
• Nuevo sistema de archivos Ext4.
• Nube de computación (múltiples aplicaciones en una sola nube).
• El paquete dovecot-postfix.

¡¡¡ Aquí, esperaremos con ansias a su llegada !!!

POST MODIFICADO (23/04/09):

¡Ya ha llegado el nuevo Ubuntu Jaunty Jackalope!

Aquí tenéis los enlaces para la descarga (torrent):

Ubuntu Desktop 9.04 i386

Ubuntu Desktop 9.04 amd64

¡Qué lo disfrutéis!

Más información en:

http://www.ubuntu-es.org

http://www.ubuntu.com

La eficiencia en la resolución del problema depende de muchos factores: la propia experiencia haciendo diseños de software, la similitud en las características con otros sistemas existentes ya implementados, la creatividad en la resolución de problemas nuevos, etc. Pero en el proceso de análisis y diseño de software, e incluso en la propia implementación, muchas veces nos encontramos con los mismos problemas a resolver. Ahí es donde entran en juego los patrones de diseño.

Los patrones de diseño son soluciones a problemas y dificultades comunes en el desarrollo de software, que obviamente han demostrado ser soluciones correctas y eficientes. Además han de ser poseer un nivel de abstracción suficiente para que sean reutilizables.

Patrones de diseño hay muchos y de muchos tipos, pero a continuación voy a tratar únicamente los patrones del GoF (Gang Of Four), autores del libro Design Patterns: Elements of Reusable Object-Oriented Software. GoF organizan su catálogo de patrones en tres ámbitos: patrones de creación, patrones estructurales y patrones de comportamiento.

Patrones de Creación

• Factory Method: Delega la creación de un objeto a las clases derivadas.
• Abstract Factory: Crea un conjunto de objetos polimórficos relacionados entre sí.
• Builder: Construye una estructura compleja a partir de trozos pequeños.
• Prototype: Construye un objeto tomando como referencia otro objeto.
• Singleton: Restringe una clase a tener una única instancia.

Patrones Estructurales

• Adapter: Adapta la interfaz de un servidor al cliente.
• Bridge: Abstracción para referirse a una implementación entre muchas.
• Composite: Estructura para conseguir agregaciones recursivas.
• Decorator: Extiende un objeto de forma transparente.
• Facade: Simplifica la interfaz de un subsistema.
• Flyweight: Permite compartir de forma eficiente entre muchos objetos pequeños.
• Proxy: Un objeto que aproxima otro objeto.

Patrones de Comportamiento

• Chain Of Responsability: Delega cada orden/comando al proveedor de servicio responsable.
• Command: Los comandos son tratados como objetos de primera clase.
• Interpreter: Intérprete de lenguaje para uan gramática reducida.
• Iterator: Permite acceso secuencial a elementos agregados.
• Visitor: Operación a ejecutar sobre el conjunto de elementos de la estructura de un objeto.
• Mediator: Coordina interacciones entre sus asociados.
• Memento: Captura y restaura los estados de los objetos de forma privada.
• Observer: Los objetos dependientes se actualizan de forma automática.
• State: Objeto con comportamiento dependiente del estado.
• Strategy: Abstracción para poder seleccionar entre muchos algoritmos existentes.
• Template Method: Algoritmo con pasos ofrecidos por una clase derivada.

Aquí os he dejado una breve descripción de cada uno de ellos para que tengáis un conocimiento general  pero todos están perfectamente documentados e ilustrados mediante diagramas en el libro del GoF [1]. Espero que os sea de utilidad y los tengáis presentes a la hora de diseñar o analizar proyectos de software.

Fuentes:

Wikipedia – http://es.wikipedia.org/wiki/Patr%C3%B3n_de_dise%C3%B1o

Más información:

McDonaldLand – CheatSheet – http://www.mcdonaldland.info/2007/11/28/40/

Bibliografía:

[1] Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides. Design Patterns: Elements of Reusable Object-Oriented Software. 1994. Ed. Addison-Wesley. ISBN:9780201633610