ProgramaciónExpress IT: Programación
Mostrando las entradas con la etiqueta Programación. Mostrar todas las entradas
Mostrando las entradas con la etiqueta Programación. Mostrar todas las entradas

lunes, 6 de agosto de 2007

¿Guia para contratar programadores?

Leyendo en la blogosfera encontré este articulo "A guide to hiring programmers: the high cost of low quality"; escrito por Frank Wiles un total desconocido para mi, pero por lo que pude averiguar de el, tiene experiencia suficiente en el campo de TI como para atreverme a mencionar esta entrada de su blog.

A los 16 años empecé a trabajar como operador técnico en una estación de radio; mas o menos en 1994, desde 2000 en esa misma estación mi trabajo se volcó completamente a las TI, primero como administrador de sistemas y web hasta convertirme en desarrollador de software independiente. Ya olvide cuantas formas de empleo y currículum e repartido a no se cuantas empresas con la esperanza de encontrar un empleo bien pagado y con retos constantes, que mantengan mi atención y el interés por seguir trabajando en determinado lugar. Asi como a mi me gustaría encontrar el empleo perfecto las empresas que buscan personal de TI (programadores en este caso particular), buscan lo mejor que pueden encontrar (basando en la relación costo-beneficio, aunque por algún extraño motivo la balanza siempre esta inclinada hacia el lado del costo olvidando el beneficio casi por completo) para cubrir sus necesidades de desarrollo.

La realidad sin embargo, es que pocas empresas están dispuestas a pagarle bien a un programador (ya ni mencionar los retos y el ambiente laboral :( ) y los pocos buenos programadores se la pasan brincando de una empresa a otra en busca de mejor paga y proyectos que cautiven su interés. Wiles y otros programadores (de Perl) como el, concluyeron lo siguiente sobre el tema de la contratación de programadores:
  • Encontrar buenos programadores es difícil en cualquier lenguaje. Un buen programador puede ser tan efectivo como 5 a 10 programadores promedio.
  • El rango de salarios entre programadores están fuera de sincronía y están basados mas en el lenguaje utilizado que en la habilidad de el programador.
  • No es necesario contratar un experto en X lenguaje, se puede y se debería buscar programadores expertos que estén dispuestos a aprender X lenguaje. Un experto puede facilmente pasar de ser un novato en cualquier lenguaje en cosa de algunas semanas.
  • Se debería considerar seriamente permitir a los programadores trabajar remotamente tiempo completo. Restringir la búsqueda a programadores que vivan cerca del área o dispuestos a moverse limita el talento que se puede adquirir. Argumentos como "tiempos de entrega", productividad, etc. se nulifican al ver como algunos y mas exitosos proyectos "Open Source" como Linux, Apache y Firefox son desarrollados por individuos que raramente viven en la misma zona, incluso el mismo país.
¿Por que es tan dificil encontrar buenos programadores?

Segun Frank, la raz
ón mas sencilla es cuando una empresa encuentra un buen desarrollador, ellos hacen mas por asegurarse que esa persona este feliz. Mejor salario, condiciones de trabajo mas flexibles, buenas herramientas, proyectos interesantes y buenos estímulos generalmente mantienen a un buen programador en el mismo lugar por mas tiempo.

Es bastante obvia la dificultad para encontrar expertos, esto no significa que los departamentos de RH se rindan y contraten lo que les llegue, los programadores no son engranes en la maquina, se acercan mas a los artistas o científicos que a un
representante de ventas o pedagogos (sin menospreciar ninguna profesión). Además muchos no es igual a mejor, si una empresa (buscando ahorrar) contrata varios novatos que le cuesten lo mismo o menos que un experto, estos seguramente se convertirán en lastres y no en propelas que impulsen el desarrollo en la empresa. Otra dificultad la presentan las propias empresas, por lo general están dispuestos a pagar de 10% a 20% mas a un experto que a un programador promedio, las empresas deben darse cuenta que pagar mas puede ahorrarles mucho a largo plazo.

Frank y compañía presentan Pros y Contras de contratar 5 programadores (de
Perl) expertos (o arriba del promedio) pagando a cada uno 120 mil USD al año:

Contras

  • Se invierte mas tiempo en encontrar, evaluar y entrevistar a los candidatos.
  • La empresa o lo que se le pide programar sencillamente podría no ser atractivo a esta clase de desarrollador. Las personas inteligentes encuentran las cosas aburridas aun mas aburridas que la mayoría.
  • Cuando uno de ellos deja la empresa los objetivos de negocio están mas en riesgo al contar con menos recursos o que una buena parte del conocimiento de la empresa se fue caminando. Esto es mas una percepción que realidad, un buen desarrollador es mejor escribiendo código legible y bien comentado, lo que ayuda a su sucesor para tomar las riendas del desarrollo mas rápido.
Pros
  • Cada desarrollador estará mas contento con su trabajo, en parte por un salario mas arriba que el promedio y por que sus compañeros son igual o mas capaces que el, lo que mejora la satisfacción del trabajo.
  • El desarrollo requiere de menos comunicación en general, pues hay menos personas con quien comunicarse.
  • Los expertos se mueven en los mismos círculos, tener un experto en el equipo hace mas fácil encontrar otros expertos.
  • Se ahorra en infraestructura (cubículos, teléfonos, computadoras, etc.).
  • El departamento de RH tiene menos gente por quien preocuparse.
  • Se ahorra mucho en costos laborales, menos empleados es igual a menos reparto de utilidades, cuotas de seguridad social, vacaciones, etc.
¿Que es un programador experto?

La experiencia es muy importante, pero no tan importante como diversidad de experiencia. Alguien que a trabajado en diferentes industrias es mucho mejor desarrollador que alguien que ha pasado años en la misma industria. Si el desarrollador a sido administrador de sistemas ese es un punto extra a su favor.

Algunos de los mejores desarrolladores tienen una formación que poco o nada tiene que ver con el desarrollo de software, no es sorprendente encontrar matemáticos, contadores, médicos, etc. escribiendo código de excelente calidad. Los expertos son flojos (en cierto sentido), trabajan inteligentemente y no arduamente, prefieren soluciones fáciles que resuelvan el problema a soluciones complejas solo por tener la complejidad (esto es algo que las empresas aman, hacer las cosas difíciles sin justificación).

¿Mas motivos para contratar expertos?

La lista podría ser interminable, pero basta mirar compañías como Google, Apple o Microsoft. Todas ellas dedican gran parte de su tiempo y departamentos de RH en buscar, contratar y hacer sentir bien a sus expertos.

Powered by ScribeFire.

jueves, 28 de septiembre de 2006

Ant 1.6.5 + Tomcat 5.5.9 + Slackware 10.1

Pues eso, como instalar Ant y Tomcat en Slackware Linux 10.1, también sirve para instalar en otras distribuciones, yo lo e probado en Red Hat Enterprise Linux 3 y CentOS 4 (RHEL 4).

Instalar j2sdk-1_5_0_01-i586-1.tgz del directorio /extra de Slackware 10.1


Descomprimir apache-ant-1.6.5.tar.bz2 en algun directorio, de preferencia como root, mover el directorio apache-ant-1.6.5 a /usr/lib/ant


# tar -xvjf apache-ant-1.6.5.tar.bz2
# mv apache-ant-1.6.5 /usr/lib/ant


Agregar en /etc/profile.d dos scripts para definir las variables de entorno que ant necesita ant.csh


#!/bin/csh
setenv ANT_HOME /usr/lib/ant
setenv PATH ${PATH}:/usr/lib/ant/bin


ant.sh


#!/bin/sh
export ANT_HOME=/usr/lib/ant
export PATH="$PATH:/usr/lib/ant/bin"


Ejecutamos los siguientes comandos para revisar que ant funcione bien.


# source /etc/profile


# ant -diagnostics


Descomprimimos jakarta-tomcat-5.5.9.tar.gz


# tar -xvzf jakarta-tomcat-5.5.9.tar.gz


Compilamos la herramienta jsvc que nos permite iniciar Tomcat como daemon.


# cd jakarta-tomcat-5.5.9/bin/jsvc-src


# autoconf


# ./configure


# make


# cp jsvc ..


# cp nativa/Tomcat5.sh /etc/rc.d/rc.tomcat5


Movemos el directorio de Tomcat a su hogar permanente en nuestro sistema.


# cd ..


# mv jakarta-tomcat-5.5.9 /usr/lib/tomcat


Movemos el directorio /webapps a un lugar mas apropiado como /var/www


# mv /usr/lib/tomcat/webapps /var/www


# ln -s /var/www/webapps /usr/lib/tomcat/webapps


Definimos la variable de entorno $CATALINA_HOME agregando los scripts correspondientes en /etc/profile.d


tomcat.csh


#!/bin/csh
setenv CATALINA_HOME /usr/lib/tomcat


tomcat.sh


#!/bin/sh
export CATALINA_HOME=/usr/lib/tomcat


Copiamos catalina-ant.jar de la biblioteca de Tomcat a la biblioteca de Ant para poder utilizar la utilidad de administración de Tomcat


# cp $CATALINA_HOME/server/lib/catalina-ant.jar $ANT_HOME/lib


Agregamos el usuario que va a ejcutar Tomcat como daemon


# useradd tomcat


Modificamos /etc/rc.d/rc.tomcat de acuerdo a nuestra configuración y lo agregamos a /etc/rc.d/rc.local


Probamos nuestra instalación apuntando nuestro navegador a http://localhost:8080


Esto debe mostrarnos la página inicial de Tomcat, si esto no sucede, entonces deberiamos revisar que jsvc se este ejecutando con:


# ps aux | grep jsvc.exec


y también revisar el archivo de logs de Tomacat.


# cat /usr/lib/tomcat/logs/catalina.out


Tags: , ,

jueves, 4 de mayo de 2006

PHP5 Clase para representar base de datos

Ya hace algún tiempo que me tope con el artículo "Going dynamic with PHP" de Jack Herrington, Senior Software Engineer, "Code Generation Network" en el sitio developerWorks de IBM.
Nos muestra como aprovechando las nuevas características de programación orientada a obejetos en PHP 5 se pueden crear objetos muy flexibles capaces de crear metodos y variables miembro al vuelo.
En la actualidad utilizo el siguiente codigo en mis aplicaciones de PHP como base, para una explicación de como funciona sugiero leer el artículo en developerWorks, yo solo lo pongo aquí para disponer de el en forma inmediata.

getMessage()); }

class DBObject
{
private $id = 0;
private $table;
private $fields = array();

function __construct( $table, $fields )
{
$this->table = $table;
foreach( $fields as $key )
$this->fields[ $key ] = null;
}

function __get( $key )
{
return $this->fields[ $key ];
}

function __set( $key, $value )
{
if ( array_key_exists( $key, $this->fields ) )
{
$this->fields[ $key ] = $value;
return true;
}
return false;
}

function load( $id )
{
global $db;
$res = $db->query(
"SELECT * FROM ".$this->table." WHERE ".
$this->table."_id=?",
array( $id )
);
$res->fetchInto( $row, DB_FETCHMODE_ASSOC );
$this->id = $id;
foreach( array_keys( $row ) as $key )
$this->fields[ $key ] = $row[ $key ];
}

function insert()
{
global $db;

$fields = $this->table."_id, ";
$fields .= join( ", ", array_keys( $this->fields ) );

$inspoints = array( "0" );
foreach( array_keys( $this->fields ) as $field )
$inspoints []= "?";
$inspt = join( ", ", $inspoints );

$sql = "INSERT INTO ".$this->table.
" ( $fields ) VALUES ( $inspt )";

$values = array();
foreach( array_keys( $this->fields ) as $field )
$values []= $this->fields[ $field ];

$sth = $db->prepare( $sql );
$db->execute( $sth, $values );

$res = $db->query( "SELECT last_insert_id()" );
$res->fetchInto( $row );
$this->id = $row[0];
return $row[0];
}

function update()
{
global $db;

$sets = array();
$values = array();
foreach( array_keys( $this->fields ) as $field )
{
$sets []= $field.'=?';
$values []= $this->fields[ $field ];
}
$set = join( ", ", $sets );
$values []= $this->id;

$sql = 'UPDATE '.$this->table.' SET '.$set.
' WHERE '.$this->table.'_id=?';

$sth = $db->prepare( $sql );
$db->execute( $sth, $values );
}

function delete()
{
global $db;
$sth = $db->prepare(
'DELETE FROM '.$this->table.' WHERE '.
$this->table.'_id=?'
);
$db->execute( $sth,
array( $this->id ) );
}

function delete_all()
{
global $db;
$sth = $db->prepare( 'DELETE FROM '.$this->table );
$db->execute( $sth );
}
}

class Book extends DBObject
{
function __construct()
{
parent::__construct( 'book',
array( 'author', 'title', 'publisher' ) );
}
}

$book = new Book( );
$book->delete_all();
$book->{'title'} = "PHP Hacks";
$book->{'author'} = "Jack Herrington";
$book->{'publisher'} = "O'Reilly";
$id = $book->insert();

echo ( "New book id = $id\n" );

$book->{'title'} = "Podcasting Hacks";
$book->update();

$book2 = new Book( );
$book2->load( $id );
echo( "Title = ".$book2->{'title'}."\n" );
$book2->delete( );
?>

miércoles, 1 de marzo de 2006

Desarrollo sobre rieles

Es probable que navegando nos topemos de vez en cuando con Ruby, un lenguaje de programación interpretado, rapido y sencillo para programación orientada a objectos, pero es también muy probable que lo pasemos por alto cuando estamos acostumbrados a trabajar con PHP, Perl o inclusive Python en nuestros proyectos web.
Hace un par de dias leyendo el artículo Going dynamic with PHP en IBM dW me tope nuevamente con Ruby, para ser exactos me tropece con rieles. Ya dijimos que es Ruby, pero, ¿Y los rieles donde encajan? Pues Ruby on Rails es un framework para desarrollar aplicaciones web que utilizan una base de datos como back end.
Ya se que existen multitud de frameworks para desarrollo web y basados en lenguajes más populares como los mencionados más arriba, pero lo que realmente sorprende de Ruby on Rails es la capacidad para desarrollar una aplicación web diez veces más rapido que con cualquiera de los frameworks más populares.
Esto es posible en parte por que en Ruby hay muchas cosas que son más fáciles de hacer que en otros lenguajes y por que Ruby on Rails favorece convención sobre configuración. Es decir que en lugar de archivos de configuración, las aplicaciones de Rails utilizan algunas convenciones simples de programación que le permiten averiguarar todo lo necesario a traves de reflexiones y descubrimientos. El codigo de la aplicación y la base de datos saben todo lo que Rails necesita saber.

En este artículo no voy a profundizar en Ruby y tampoco en Rails, al final hay una lista de links con más información al respecto y es muy probable que en algun momento escriba alguna introducción a Rails con alguna aplicacion de ejemplo, por el momento solo dire como instalar rails en Linux (especificamente Ubuntu 6.06 LTS)


  1. ~$ sudo apt-get install ruby ri rdoc libmysql-ruby
  2. Descarga rubygems de http://rubyforge.org/projects/rubygems/
  3. ~$ tar xvzf rubygems-x.x.x.tar.gz (reemplaza x.x.x por el numero de version descargada)
  4. ~$ cd rubygems-x.x.x
  5. ~/rubygems-x.x.x$ sudo ruby setup.rb
  6. ~/rubygems-x.x.x$ sudo gem install rails --include-dependencies
Ahora estas listo para andar sobre rieles.

¿Que hay de rails en Windows? Ok, para instalar Rails en Windows hay dos caminos (en Linux también hay varias formas), aquí describo la instalación recomendada en el libro "Agile web development with rails" de Dave Thomas y David Heinemeier Hansson.

  1. Crear un folder para almacenar la instalación de InstantRails, que no contenga espacios en la ruta C:\rails es una buena elección.
  2. En el sitio http://instantrails.rubyforge.org/wiki/wiki.pl descarga el archivo .zip de InstantRails
  3. Descomprime el archivo en el directorio creado en el paso 1
  4. Dentro del directorio InstantRails ejecuta el archivo InstantRails (el del ícono I)
  5. Si aparece un cuadro de diálogo preguntando si deseas regenerar los archivos de configuración haz click en OK
  6. Si tienes instalado y corriendo IIS aparecerá un cuadro de diálogo advirtiendo que el puerto 80 usado por Apache esta bloqueado, puedes dejarlo así, para el desarrollo con Rails no es necesario ningún servidor web. Rails incluye Webrick como servidor web de desarrollo.
  7. Aparecerá una ventana de InstantRails, aquí puedes utilizar y monitorear las aplicaciones Rails.

Para trabajar con Rails será necesario usar una ventana de línea de comandos, click en el boton I ->Rails Applications->Open Ruby Console Window

Si intentas trabajar con Rails desde una línea de comandos normal no va afuncionar, ya que InstantRails es autocontenido, así que siempre sigue el procedimiento descrito (a partir del paso 4) para ejecutar y trabajar con InstantRails.

InstantRails incluye además de Ruby, rubygems y Rails; el servidor web Apache, MySQL, PHP y phpMyAdmin, el editor de texto Scite, FreeRIDE un IDE para Ruby y el texto completo del libro "Programming Ruby: The pragmatic programmer's guide" de DAvid Thomas y Adrew Hunt en formato .chm

Ahora sí usuarios de Windows, estan listos para andar sobre rieles.

Infromacion de Rails:

  1. http://rubyonrails.org/
  2. http://groups.google.com/group/rubyonrails-talk
  3. Canal IRC en irc.freenode.net #rubyonrails
  4. Un excelente libro para iniciar con Rails http://www.pragmaticprogrammer.com/titles/rails2/