coge la información y corre

Guia básica para editar imágenes en PHP con GD

14 de octubre del 2008 Escrito por Alex Barros

Crear y editar imágenes con PHP puede ser muy fácil si tienes instalada la biblioteca GD en tu servidor.

Aunque las opciones que ofrece GD son muy básicas, son suficientes para desarrollar scripts con capacidades muy superiores. Ahora voy a presentaros estas funciones básicas con ejemplos, para que puedas crear aplicaciones más complejas.

Crear la imagen de cero o desde un archivo

Para tratar imágenes en GD trabajamos con recursos o variables tipo resource de imágenes. Esto es una varible que representa a la imagen.

Para crear un nuevo recurso de imagen podemos usar la función imagecreate() aúnque es más recomendable usar la función imagecreatetruecolor()

  1. $im = imagecreatetruecolor(300, 200); //a partir de aqui trabajo con una imagen de 300×200
  2. $im2 = imagecreatetruecolor(100, 100); //he creado otra imagen distinta con dimensiones 100×100

Si queremos partir de una imagen ya existente, para convertirla en recurso tendremos que usar la función adecuada dependiendo del formato de la imagen. Los principales formatos son JPEG, PNG y GIF; con las funciones imagecreatefromjpeg(), imagecreatefrompng() y imagecreatefromgif() respectivamente.

  1. $miJpeg =imagecreatefromjpeg(‘miimagen.jpg’); //he creado un recurso a partir del archivo miimagen.jpg

Si quieres ahorrarte el pensar a la hora de crear un recurso a partir de imagen, o desconoces el formato de entrada de la imagen (y quieres que lo haga automáticamente) puedes usar esta función para crear cualquier tipo de imagen.

  1. function newimage($src) {
  2.     $im = false;
  3.     switch(true) {
  4.         case eregi(‘http://’, $src):
  5.             $im = imagecreatefromstring( getUrlData($src) );
  6.             imagealphablending($im, true);
  7.             imagesavealpha($im, true);
  8.         break;
  9.         case eregi(\.jpg’, $src):
  10.             $im = imagecreatefromjpeg($src);    
  11.         break;
  12.         case eregi(\.gif’, $src):
  13.             $imp = imagecreatefromgif($src);
  14.  
  15.             $x = imagesx($imp);
  16.             $y = imagesy($imp);
  17.             $im = imagecreatetruecolor($x, $y);
  18.             imagefilledrectangle( $im, 0, 0, $x, $y, imagecolorallocate($im, 255, 255, 255) );
  19.             imagecopy($im, $imp, 0, 0, 0, 0, $x, $y);
  20.         break;
  21.         case eregi(\.png’, $src):
  22.             $im = imagecreatefrompng($src);    
  23.  
  24.             imagealphablending($im, true);
  25.             imagesavealpha($im, true);
  26.         break;
  27.     }
  28.     return $im;
  29. }
  30. function getUrlData($url){
  31.     $ch = curl_init($url);
  32.     curl_setopt($ch, CURLOPT_FAILONERROR, 1);
  33.     curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 30);
  34.     curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
  35.     $get = curl_exec($ch);
  36.     curl_close($ch);
  37.     return $get;
  38. }

[descargar código]

Esta función puede crear una imagen a partir de JPEG, PNG, GIF o URL (requiere CURL)

Si queremos saber las dimensiones de un recurso de imagen, usaremos las funciones imagesx($im) e imagesy($im) que devuelven el ancho y alto del recurso, en píxeles, respectivamente.

Copiar, recortar y redimensionar

La modificación más básica que podemos hacer a una imagen es recortarla y redimensionarla.

En ambos casos la forma de trabajar es, en primer lugar crear un nuevo recurso con las dimensiones apropiadas, y en segundo lugar copiar de la imagen origen a la imagen destino aplicando el cambio deseado.

Recortar una imagen

Para recortar una imagen de, por ejemplo, 500 x 400 en 50px por la derecha y por abajo, haremos lo siguiente:

  1. Creamos un nuevo recurso de 500 – 50 = 450 por 400 – 50 = 350px
  2. Usamos la función imagecopy para copiar de la imagen origen, en nuestra nueva imagen

    bool imagecopy ( resource $im_destino , resource $im_origen , int $pos_x_destino , int $pos_y_destino , int $pos_x_origen , int $pos_y_origen , int $ancho_origen , int $alto_origen )

  3. Los dos primeros parámetros son los recursos destino y origen
  4. Los dos siguientes son la posición en eje x e y de la imagen destino, donde queremos comenzar a copiar (en nuestro caso 0,0; porque el eje está arriba y a la izquierda)
  5. Los dos siguientes son el ancho y el alto de la imagen que queremos recortar del aimagen original. En nuestro caso 450 y 350.
  1. $im_origen = imagecreatefromjpeg(‘mi_imagen.jpg’); //sabemos que mide 500 x 400
  2. $im_destino = imagecreatetruecolor(450, 350); //im_destino contendrá la nueva imagen recortada
  3.  
  4. imagecopy($im_destino, $im_origen, 0, 0, 0, 0, 450, 350);
  5. // Ahora im_destino es im_origen recortada por abajo y por la derecha 50px

[descargar código] Ejemplo: [original] [recortada dinámicamente]

Redimensionar una imagen

En este ejemplo vamos a redimensionar a la mitad la imagen origen, sea cual sea su tamaño.

Crearemos primero un nuevo recurso con las dimexiones x/2 e y/2, y usaremos la función imagecopyresampled() (también podríamos usar imagecopyresized(), pero la que vamos a usar suaviza los píxeles interpolándolos – tiene mejor calidad)

  1. $im_origen = imagecreatefrompng(‘foo.png’);
  2. $ancho = imagesx($im_origen);
  3. $alto = imagesy($im_origen);
  4.  
  5. $nuevo_ancho = round($ancho / 2);
  6. $nuevo_alto = round($alto / 2);
  7.  
  8. $im_destino = imagecreatetruecolor($nuevo_ancho, $nuevo_alto);
  9. imagecopyresampled($im_destino, $im_origen, 0, 0, 0, 0, $nuevo_ancho, $nuevo_alto, $ancho, $alto);
  10. // ahora im_destino es la mitad de grande que im_origen

Dibujar figuras y texto

Las figuras que GD nos deja pintar son muy básicas, parecidas a las que ofrece el programa Paint

En este punto lo más importante es crear colores para una imagen. Los colores se deben crear y asociar a una imagen mediante la función imagecolorallocate(). El color lo indicamos mediante parámetros RGB (Red Green Blue) que podemos extraer fácilmente de cualquier paleta, como la del Photoshop o el Gimp

Dibujar un rectángulo

Quizás la figura más simple. Podemos dibujar sólo el borde del rectángulo con la función imagerectangle() o el rectangulo relleno de color, con la función imagefilledrectangle()

bool imagerectangle ( resource $imagen , int $x1 , int $y1 , int $x2 , int $y2 , int $color )

bool imagefilledrectangle ( resource $imagen , int $x1 , int $y1 , int $x2 , int $y2 , int $color )

  1. $imagen = imagecreatefromjpeg(‘mi_imagen.jpg’);
  2. $negro = imagecolorallocate($imagen, 0, 0, 0);
  3. //voy a dibujar un rectangulo negro entre las coordenadas (5,5) y (25,15), recuerda que el eje está arriba a la izquierda
  4. imagefilledrectangle($imagen, 5, 5, 25, 15, $negro);

Otras figuras

Existen muchas figuras que puedes dibujar con GD, desde una línea hasta un polígono, pasando por la elipse o el píxel. Sólo busca la que más te conviene en la documentación, o combina varias para obtener la figura deseada.

Escribir texto

Es realmente sencillo. Si no te quieres complicar la vida, puedes usar la función imagestring() que te da la opción de elegir entre 5 fuentes internas indicando sólo el número de referencia…

  1. $im = imagecreate(100, 30); //creo una nueva imagen de 100×30
  2. $fondo = imagecolorallocate($im, 255, 255, 255); //blanco. El primer color creado, se utiliza como fondo automaticamente para esa imagen
  3. $color_texto = imagecolorallocate($im, 0, 0, 255); //azul
  4. // escribo la cadena arriba a la izquierda con la fuente #5
  5. imagestring($im, 5, 0, 0, "¡Hola mundo!", $color_texto);

… o si quieres tener más control sobre el estilo, puedes usar fuentes TrueType con la función imagettftext() (en la web DaFont tienes miles de fuentes TrueType gratuitas)

  1. $im = imagecreatetruecolor(400, 30); //creo una nueva imagen de 400×30
  2. // creo algunos colores
  3. $blanco = imagecolorallocate($im, 255, 255, 255);
  4. $gris   = imagecolorallocate($im, 128, 128, 128);
  5. $negro  = imagecolorallocate($im, 0, 0, 0);
  6. imagefilledrectangle($im, 0, 0, 399, 29, $blanco); //relleno el fondo
  7.  
  8. // El texto a pintar
  9. $texto = "Boozox.net";
  10. // El archivo ttf, escribe la ruta correctamente!!
  11. $fuente = ‘fuente.ttf’;
  12.  
  13. // Agrego una sombra al texto
  14. imagettftext($im, 20, 0, 11, 21, $gris, $fuente, $texto);
  15.  
  16. // Escribo el texto
  17. imagettftext($im, 20, 0, 10, 20, $negro, $fuente, $texto);

[descargar código]
Demo:

Tratar bien la transparencia en PNG

Las imágenes PNG admiten un canal Alpha que indica la opacidad en cada punto de la imagen, para crear efectos semitransparentes. Si te interesa que esta transparencia se muestre correctamente, deberás calentarte un poco más la cabeza, y tener el canal Alpha siempre en cuenta. Te aconsejo que incluyas estas dos líneas después de crear una nueva imagen con transparencia (aunque tendrás que estar siempre atento de que el canal alpha no se pierda!)

  1. $im = imagecreatefrompng(‘mi_transparencia.png’);    
  2. //conservar transparencia
  3. imagealphablending($im, true);
  4. imagesavealpha($im, true);

Recuerda también que puedes crear colores con canal de transparencia usando imagecolorallocatealpha() en lugar de imagecolorallocate()

Exportar la imagen para visualizarla

Después de haber modificado nuestra imagen tal como deseamos, tendremos que exportarla. Existe una función para cada formato de salida (imagejpeg(), imagepng(), imagegif(), etc…). Personalmente te recomiendo siempre exportar en PNG porque se conserva la calidad y la nitidez mucho mejor.

En todos los casos tendremos la opción de generar el código de la imagen, si queremos que el archivo PHP simule ser la propia imagen, o indicarle dónde queremos que almacene la imagen resultado.

Para el primer caso, tendremos que indicar mediante las cabeceras que lo que estamos a punto de mostrar es una imagen. Para esto usamos la función header() indicando el tipo de archivo en concreto de que se trata (image/jpeg, image/png o image/gif).

  1. //este codigo se incluiria al final del proceso de edicion, suponiendo que $im es el recurso de la imagen que queremos mostrar
  2. header("Content-type: image/png");
  3. imagepng($im);

Una vez creado este archivo, podemos mostrar el resultado en una página HTML simplemente creando una etiqueta de imagen que referencie a ese archivo .php

  1. <img src="imagen.php" />

Si queremos almacenar en nuestro disco la imagen resultante, tendremos que pasar como segundo parámetro a la función el nombre del archivo que queremos generar.

  1. imagepng($im,‘ruta/miarchivo.png’);

Recuerda que me interesa mucho tu opinión. Crees que falta algo? tienes dudas? vas a trabajar con la librería GD ahora que sabes cómo funciona? has hecho experimentos curiosos con imágenes dinámicas? …

Categorias: Código, Imagen Digital, PHP, Ubuntu | 53 comentarios »

Redimensionar en PHP a tamaño fijo

20 de septiembre del 2008 Escrito por Alex Barros

Ver también Guía básica para editar imágenes en php con GD

Esta es una técnica para redimensionar imágenes a un tamaño fijo (aunque no guarde proporción), sin distorsionar la imágen.

No, no se trata del escalado líquido. Esa técnica es demasiado compleja. Se trata de recortar la imágen para adaptarla a la nueva resolución, perdiendo el mínimo espacio posible.

Foto de Basajaun en Flickr Licencia CC(by-nc-sa)

Para hacer esto, he desarrollado este algoritmo, que paso a compartir con todos para que lo uséis como os de la gana (requiere Biblioteca GD)

  1. function resizeFit($im,$width,$height) {
  2.     //Original sizes
  3.     $ow = imagesx($im); $oh = imagesy($im);
  4.    
  5.     //To fit the image in the new box by cropping data from the image, i have to check the biggest prop. in height and width
  6.     if($width/$ow > $height/$oh) {
  7.         $nw = $width;
  8.         $nh = ($oh * $nw) / $ow;
  9.         $px = 0;
  10.         $py = ($height$nh) / 2;
  11.     } else {
  12.         $nh = $height;
  13.         $nw = ($ow * $nh) / $oh;
  14.         $py = 0;
  15.         $px = ($width$nw) / 2;
  16.     }
  17.    
  18.     //Create a new image width requested size
  19.     $new = imagecreatetruecolor($width,$height);
  20.    
  21.     //Copy the image loosing the least space
  22.     imagecopyresampled($new, $im, $px, $py, 0, 0, $nw, $nh, $ow, $oh);
  23.    
  24.     return $new;
  25. }

[Descargar código]

Cómo utilizar

Si no estás familiarizado con la edición de imágenes en PHP, no te preocupes. Para utilizar la función de arriba, tenemos que pasarle como parámetro una imágen tipo resource de GD y dos números indicando el ancho y alto que queréis forzar a la foto.

Para que se vea, hay que editar las cabeceras HTTP indicando que el contenido es una imágen. Y a este archivo de imágen (aunque sea un PHP) se le puede llamar desde la etiqueta img de HTML. Dejemos que hable el código:

imagen.php

  1. //Primero creo el resource de la imagen desde el original en JPEG
  2. $im = imagecreatefromjpeg(‘original.jpg’);
  3.  
  4. //Ahora uso la función antes definida, con unos parámetros de ancho y alto que yo quiera
  5. $resized = resizeFit($im, 100, 150);
  6.  
  7. //Indico en la cabecera HTTP que es una imagen
  8. header("Content-type: image/png");
  9.  
  10. //Por último exporto la nueva imagen
  11. imagepng($resized);

miPagina.html

  1. <p>Esta es mi foto redimensionada a 100 x 150:</p>
  2. <img src="imagen.php">

Puedes ver un ejemplo en …

Esta técnica la uso en Gpsia para mostrar las imágenes al tamaño que yo le diga, sin que se vean distorsionadas. Échale un ojo, y de paso ves las rutas tan increíbles que está subiendo la gente.

Categorias: Código, Diseño, Imagen Digital, PHP | 5 comentarios »

HTML del visor de Youtube a partir de su URL

4 de septiembre del 2008 Escrito por Alex Barros

Esta es una función que acabo de crear para transformar una URL de un vídeo de youtube en el código HTML del visor.

Aúnque la URL sea de las enrevesadas, la función sigue interpretando correctamente.

http://es.youtube.com/watch?v=V0w2D0Kxq3Q&feature=PlayList&p=0704B55480867B61&index=3&playnext=1&playnext_from=PL

La magia reside en la expresión regular que me he currado

^http://([^\.]{0,2}\.)?youtube.com/watch\?.*v=([^&]+)&?.*$

Podéis usarla para lo que os de la gana, la licencia es Dominio Público.

  1. function youtubeUrlToHTML($url, $width = 425, $height = 344) {
  2.         if(!eregi("^http://(www.)?([^\.]{0,2}\.)?youtube.com/watch\?.*v=([^&]+)&?.*$",$url,$regs)) return false;
  3.         $key = $regs[3];
  4.        
  5.         return ‘<object width="’.$width.‘" height="’.$height.‘"><param name="movie" value="http://www.youtube.com/v/’.$key.‘&hl=es&fs=1"></param><param name="allowFullScreen" value="true"></param><embed src="http://www.youtube.com/v/’.$key.‘&hl=es&fs=1" type="application/x-shockwave-flash" allowfullscreen="true" width="’.$width.‘" height="’.$height.‘"></embed></object>’;
  6. }

[Demo] [Código]

Y si crees que la puedes mejorar… a que no me dices eso en la calle!!

Mejor dilo en los comentarios

Aportación de Javier:
Javier propone una forma de hacer lo mismo sin utilizar expresiones regulares, haciendo uso de parse_url y parse_str:

  1. function youtubeUrlToHTML($url, $width = 425, $height = 344) {
  2.         parse_str( parse_url( $url, PHP_URL_QUERY ) );
  3.         $key = !empty( $v ) ? $v : $url;
  4.        
  5.         return ‘<object width="’.$width.‘" height="’.$height.‘"><param name="movie" value="http://www.youtube.com/v/’.$key.‘&hl=es&fs=1"></param><param name="allowFullScreen" value="true"></param><embed src="http://www.youtube.com/v/’.$key.‘&hl=es&fs=1" type="application/x-shockwave-flash" allowfullscreen="true" width="’.$width.‘" height="’.$height.‘"></embed></object>’;
  6. }

Muchas gracias por tu aportación!

Categorias: Código | 6 comentarios »

MySQL – Seleccionar al azar, o lista desordenada

11 de agosto del 2008 Escrito por Alex Barros

Tan sencillo como usar la función RAND() de MySQL.

La clave está en ordenar los elementos seleccionados por un parámetro aleatorio. Un ejemplo sería esta sentencia:

  1. SELECT * FROM mi_tabla WHERE a > 10 AND b < 200 ORDER BY RAND()

Esto nos daría los resultados que queremos, ordenados aleatoriamente.

Si queremos coger un sólo registro al azar, no tenemos más que limitar el anterior Select a un registro.

  1. SELECT * FROM mi_tabla WHERE a > 10 AND b < 200 ORDER BY RAND() LIMIT 1

Como diría Janet Jackson, I want FeedBack!!

Categorias: Código, MySQL | 3 comentarios »

Parsear un archivo XML con PHP y DOM.XML

6 de agosto del 2008 Escrito por Alex Barros

Brevemente voy a introducir el uso de la extensión DOM.XML de PHP

Podemos leer un archivo XML a partir de una cadena de texto (con domxml_open_mem) o diciendo dónde está el archivo XML ( con domxml_open_file)

Como ejemplo usaremos el archivo XML que proporciona el API Google Weather (no documentada) para hacer predicciones meteorológicas en determinado lugar.

  1. $xml = domxml_open_file(‘http://www.google.com/ig/api?hl=es&weather=Madrid’); //En este caso la prediccion para madrid

El método más importante es get_elements_by_tagname, que nos devuelve los tags que tienen ese nombre, en forma de array.

En nuestro caso, vamos a hacer una comprobación por si el documento XML nos informa de que ha habido un error, con el tag problem_cause ver ejemplo

  1. $problem = $xml->get_elements_by_tagname(‘problem_cause’);
  2. if($problem) {
  3.         $problem_cause = $problem[0]->get_attribute_node(‘data’);
  4.         die($problem_cause);
  5. } else {
  6. }

Para obtener la descripción, tendremos que usar el método get_attribute_node que nos dice el valor del atributo que queramos, para un elemento [nombreTag atributo="valor"].

Y ahora, vamos a ir directos al ajo. Echad un vistazo a la estructura del API Google Weather, y al siguiente código, después lo explico.

  1. //Esta funcion nos ayuda a sacar el atributo "data" del "tag" de un nodo dado
  2. function getTagDataFromNode($tag,$node){
  3.         $child = $node->get_elements_by_tagname($tag);
  4.         $data = $child[0]->get_attribute_node(‘data’);
  5.         return $data->value();
  6. }
  7.  
  8. //Extraigo la informacion de la prediccion
  9. $infoTag = $xml->get_elements_by_tagname(‘forecast_information’);
  10. $city = getTagDataFromNode(‘city’,$infoTag[0]); //La ciudad
  11. $date = getTagDataFromNode(‘forecast_date’,$infoTag[0]); //La fecha de la prediccion
  12.  
  13. echo "<h1>Prediccion en $city ($date)</h1>";
  14.  
  15. //Prediccion para los proximos dias
  16. $items = $xml->get_elements_by_tagname(‘forecast_conditions’);
  17.  
  18. foreach($items as $item){
  19.         echo "<p><strong>".getTagDataFromNode(‘day_of_week’,$item)."</strong> <br>";
  20.         echo "<img src=\"http://google.com".getTagDataFromNode(‘icon’,$item)."\"><br>".getTagDataFromNode(‘condition’,$item).".<br>";
  21.         echo "Temperaturas entre ".getTagDataFromNode(‘low’,$item)." &deg;C y ".getTagDataFromNode(‘high’,$item)." &deg;C</p>";
  22. }

[Ver resultado]

La función que se define al comienzo sirve para ahorrarnos código al extraer el atributo “data” de los nodos, porque todos los tags tienen lo importante ahí.

El resto del código creo que está bastante claro. Puedes ver una [Demo] y el [código fuente].

Si te ha gustado el post, te parece interesante, o tienes dudas escríbeme un comentario, tengo ganas de leerte!

Nota: Si no tienes esta extensión instalada en tu host, pregunta al servicio técnico para que te lo instalen, o mira esta página para hacerlo tú mismo.

Categorias: Aplicaciones, Código, PHP | 18 comentarios »

Geolocalizar usuarios con su IP

5 de agosto del 2008 Escrito por Alex Barros

estoy-aquiOs quiero comentar brevemente cómo saber el País del que provienen vuestros visitantes, usando su IP, y la base de datos de MaxMind

Para tener esta feature, descargamos la última versión de GeoLite Country (es la versión gratuita de la base de datos).

Esto es un archivo comprimido, que contiene un archivo tipo DAT. Lo descomprimimos en nuestro directorio, y nos olvidamos de él.

Si vais a programar en PHP aquí hay algunos archivos de muestra. También hay soporte para otros lenguajes.

El que más nos importa es el archivo geoip.inc que contiene la librería para gestionar la base de datos en PHP. Guardamos el archivo en el mismo directorio que la base de datos.

Ahora, sólo nos queda un poco de código:

  1. <?php
  2. // Este codigo muestra como usar la API de GeoIP
  3.  
  4. include("geoip.inc");
  5. $gi = geoip_open("GeoIP.dat",GEOIP_STANDARD);
  6. $cc = geoip_country_code_by_addr($gi, $_SERVER[‘REMOTE_ADDR’]);
  7. geoip_close($gi);
  8.  
  9. echo "El codigo de tu pais es: $cc";
  10. ?>

Ver ejemplo

Esto mostrará por pantalla algo como

El codigo de tu pais es: ES

Si queremos usar el nombre del país en Español, podéis descargaros este archivo que he preparado. Contiene un array asociativo con las claves de los paises, y sus valores, usadlo así:

  1. <?php
  2. // Este codigo muestra como usar la API de GeoIP
  3.  
  4. include("geoip.inc");
  5. include("paises.inc");
  6. $gi = geoip_open("GeoIP.dat",GEOIP_STANDARD);
  7. $cc = geoip_country_code_by_addr($gi, $_SERVER[‘REMOTE_ADDR’]);
  8. geoip_close($gi);
  9.  
  10. echo "Tu vienes de ".utf8_decode($PAISES[$cc]);
  11. ?>

Ver ejemplo

Debería aparecer algo similar a:

Tu vienes de España

Nota1: Recomiendo tener todos los archivos en el mismo directorio, si no lo hacéis así, tened cuidado con poner bien la ruta a cada archivo!

Nota2: Si algún código que has copiado de esta web no te funciona, comprueba que las comillas sean correctas (reescríbelas con tu teclado) WordPress traduce las comillas simples y dobles que se usan en código, por otras raras que se usan en textos.

Categorias: Código, PHP, Review | No hay comentarios »

Ejecuta código C, Perl, Python… via web

14 de abril del 2008 Escrito por Alex Barros

code.jpg2 Una vez más se demuestra mi teoría de que TODO puede hacerse via web, sólo se necesitan programadores dispuestos a crear el servicio.

Esta vez es el caso de un compilador/intérprete de lenguajes via web. Se llama CodePad, y admite lenguajes tan conocidos como C, C++, D, Perl, Python, Ruby y algunos más.

He hecho unas cuantas pruebas con código C rebuscado y efectivamente compila y ejecuta de forma correcta, incluso te explica los errores de código si los hay.

Una idea similar tube hace algún tiempo, pero no fructificó el proyecto, ahora me quito el sombrero ante lo que ha hecho Steven Hazel (el desarrollador). Parece ser que ha sido desarrollado en Python, y que ha puesto énfasis en la seguridad. Aún así insta a hackers que comuniquen sus éxitos.

A partir del buen servicio que ha conseguido CodePad, se podría explotar ahí una comunidad de desarrolladores muy guapa, o crear toda una plataforma web para programadores, para que cuelguen sus proyectos de Software Libre, los promocionen, interactúen, y tengan a mano herramientas tan interesantes como el compilador, o un editor de código que esté bien. Sería una idea nada despreciable.

via wwWhat’s New

Categorias: Aplicaciones, C, Código | 3 comentarios »

Apoyemos al PHP!

11 de abril del 2008 Escrito por Alex Barros

A raíz del post anterior haciendo mimetismos entre lenguajes de programación y embarcaciones, nos encontramos con que al lenguaje de programación PHP se le asignaba una triste balsa de bambú.

PHP is a bamboo raft. A series of hacks held together by string. Still keeps afloat though.

PHP es una balsa de bambú. Unos cuantos apaños unidos con una cuerda. Aún así consigue ir a flote

Me parece un juicio muy injusto, y a los comentaristas de Boozox también!

  • Memiux: [...] un poco exagerado lo de PHP xD
  • daniel: El que diga eso de php, es que no tiene ni idea [...]
  • Jose D: [...] yo también defiendo a php que está que se sale por todos lados [...]

Coincido con todos ellos, PHP no es una triste balsa da bambú! PHP es un lenguaje muy potente sobretodo para lo que está enfocado (desarrollo de webs dinámicas). Cuenta con infinidad de funciones y bibliotecas útiles para cualquier cosa que se te pase por la mente, y de hecho un porcentaje muy elevado (la mayor parte) de las webs en internet están respaldadas por este lenguaje.

No en vano, webs como Youtube, yahoo, wikipedia, facebook, digg, flickr…. han elejido como lenguaje idóneo el PHP.

Se le acusa de provocar desorden en el código y en la estructura de los programas, pero esto es un hecho que se desprende de la habilidad y la experiencia de quien programa.

Es posible que el hecho de que la versatilidad y facilidad de PHP permita su uso a personas inexpertas, de como resultado la proliferación de código de mala calidad, pero no se puede generalizar, y declarar que en PHP se programan apaños y chapuzas.

He programado toda mi vida en PHP y jamás me ha presentado una frontera, el límite ha sido siempre mi imaginación.

Por ello quiero defender el papel de PHP, y promover su uso para cualquier tipo de tarea en internet.


Larga vida a PHP !!!!

Categorias: Aplicaciones, Código, Opinión, PHP | 10 comentarios »

Se llama Geo y es Libre

29 de marzo del 2008 Escrito por Alex Barros

De acuerdo, voy a comentaros qué me ha tenido todo este tiempo tan ausente.

He dedicado la mayor parte de mi tiempo a desarrollar la primera versión de la aplicación Geo. Geo es una aplicación web para compartir rutas captadas con GPS.

Detrás de Geo hay toda una infraestructura de objetos y algoritmos que me ha costado mucho de elaborar (los últimos tres meses), pero puedo decir que estoy muy orgulloso del resultado, y es una base genial para continuar haciendo de Geo una herramiente potente de aquí en adelante.

Como es lógico he liberado Geo (en realidad se llama GeoGPS) con la licencia GNU/GPL, pero esta vez he querido llegar más lejos, y lo he enviado como proyecto a Sourceforge, donde tendrá todas las atenciones que un buen proyecto libre merece.

Por ahora podéis leer (y agregaros al RSS) el blog que he creado y actualizo para este proyecto, y navegar entre las casi 100 rutas con las que ya cuenta la web de Geo.

Me disculpo por la escasa actualización de este blog. Entre la universidad y proyectos como Geo, no me queda apenas tiempo… :(

Un saludo a todos!

Categorias: Aplicaciones, Código, Novedades, Software libre | 4 comentarios »

Hacer que una web no se vea en Internet Explorer

1 de marzo del 2008 Escrito por Alex Barros

Programando una web, me he topado con esta curiosidad.

El código es el siguiente:

  1.  
  2. <head>
  3. <title>Titulo de la pagina<title>
  4. </head>
  5.  

ie7.jpgNótese que la etiqueta TITLE no se cierra correctamente.

Di con esto por accidente, pero me resultó curioso que navegadores como Firefox o Safari visualizaran correctamente la página, mientras que Internet Explorer símplemente mostraba una pantalla en blanco.

Una nueva técnica para fanáticos anti IE (qué desarrollador no lo es…)?

En cualquier caso es una falta intencionada de sintaxis, que por mucho odio que tengamos a este navegador, no deberíamos cometer.

Categorias: Bug, Código, Curioso, HTML, Internet Explorer | 4 comentarios »

« Entradas Anteriores

del.icio.us meneame.net RSS

Search:

Bicivalencia Localiza las estaciones de Valenbisi, servicio público de bicicletas en Valencia, España. Ver más Gpsia Descubre y comparte rutas por todo el mundo, tomadas con GPS. Ver más Imaset Edita tus imágenes de Wordpress con este sencillo plugin. Ver más

¡Mi música es tuya!

Digo yo que...

Mis fotos de Flickr

Entradas recientes

Meta:

Respeta el copyleft

,