Desarrollo y otras yerbas

OpenSSL y Mac OS X "El Capitán"

2016-11-24T14:02:00.002-03:00

Apple removed the OpenSSL header files in "El Capitan", making it hard to build OpenSSL-dependent libraries without modifying your system a little bit.

Fortunately we have Homebrew; if you don't have it yet, go ahead and install it now. I'll wait here.

Ready? Now, repeat after me:

$ brew doctor (now fix anything that it tells you to fix)

$ brew update

$ brew upgrade

We're just warming up with all that; it's good to stay current with things like OpenSSL, which tends to go stale fast. Now let's install it:

$ brew install openssl

And now we'll link it into our public area so you don't have to figure out the magic environment variable to set while building your favorite OpenSSL-backed library:

$ cd /usr/local/include

$ ln -s ../opt/openssl/include/openssl .

All done! Now you have an OpenSSL installed that you can build against easily and will stay up to date as often as you run brew update and brew upgrade.

Fuente: https://solitum.net/openssl-os-x-el-capitan-and-brew/

Instalar última versión de Node JS en Ubuntu 12.04

2015-04-28T12:40:00.002-03:00

Normalmente Node JS esta entre los repositorios de Ubuntu 12.04, pero no la última version.
Para eso debemos agregar un repositorio que nos permitirá instalar la última version de este paquete.

Para eso primero agregamos el repositorio de Launchpad de Chris Lea, desde una consola debemos correr los siguientes comandos:

apt-get install python-software-properties
apt-add-repository ppa:chris-lea/node.js
apt-get update

Instalamos Node JS:

apt-get install nodejs

Check node.js version:

node -v

Salida:

v0.10.20

Instalacion de npm:

Con la instalación de Node deberíamos tener ya instalado el gestor de paquetes.

Chequeamos la versión instalada:

npm -v

Salida:

1.4.3

Si por alguna razón no se instaló, podemos con el siguiente comando bajar e instalar el paquete:

apt-get install npm

Fuente: https://rtcamp.com/tutorials/nodejs/node-js-npm-install-ubuntu/

Cómo configurar Apache Virtual Hosts en Ubuntu 12.04

2013-12-12T16:15:00.001-03:00

Vamos a explicar como crear un virtualhost en una pc para desarrollo.
Se tendrá como base un sistema operativo Ubuntu 12.04 con Apache y PHP

¿Qué son los Virtual Hosts?Los Virtual Hosts son usados normalmente para correr mas de un dominio sobre una misma dirección IP. Esto es muy util para los que necesitan correr varios sitios en un solo VPS. Los sitios de muestran segun a que dominio solicitaron. No hay limities en cuanto a Virtual Hosts se pueden agregar en un VPS

Set UpEn este paso vamos a requerir privilegios. Luego debemos tener instalado Apache en nuestro sistema o VPS:

sudo apt-get install apache2

Paso 1 - Creamos nuestro directorio

El primer paso será crear un directorio para nuestro Virtual Host donde alojaremos nuestro sitio.

Este será nuestro Document Root en el archivo de configuracion virtual de Apache. Adicionando el parámetro -p nos creara el directorio y los padres en caso de no existeir para nuestro nuevo directorio.

sudo mkdir -p /var/www/example.com/public_html

Ahora necesitaras designar unos DNS o una IP para testear que el virtual host funciona. En este tutorial usamos el dominio example.com como placeholder.

De todas formas, puedes usar un dominio inexistente para testear localmente el proceso, esto lo podremos ver en el Paso 7.

Paso 2 - PermisosNecesitamos dar el ownership del directorio al usuarioWe need to grant ownership of the directory to the user, instead of just keeping it on the root system.

 sudo chown -R $USER:$USER /var/www/example.com/public_html

Ademas, es importante asegurarnos de que podamos acceder y leer los archivos

 sudo chmod -R 755 /var/www

Ahora si tenemos ya los permisos.

Paso 3 - Crear el sitio o la pagina

Con la configuración de nuestro directorio necesitamos crear un nuevo archivo llamado index.html

sudo nano /var/www/example.com/public_html/index.html

Podemos agregar algo de texto para poder visualizar cuando nos redireccione al virtual hostWe can add some text to the file so we will have something to look at when the IP redirects to the virtual host.

<html>
  <head>
    <title>www.example.com</title>
  </head>
  <body>
    <h1>Success: You Have Set Up a Virtual Host</h1>
  </body>
</html>

Save and Exit

Step Four—Create the New Virtual Host File

The next step is to set up the apache configuration. We’re going to work off a duplicate—go ahead and make a copy of the file (naming it after your domain name) in the same directory:

 sudo cp /etc/apache2/sites-available/default /etc/apache2/sites-available/example.com

Step Five—Turn on Virtual Hosts

Open up the new config file:

 sudo nano /etc/apache2/sites-available/example.com

We are going to set up a virtual host in this file.
The first step is to insert a line for the ServerName under the ServerAdmin line.

  ServerName example.com

The ServerName specifies the domain name that the virtual host uses.

If you want to make your site accessible from more than one name (for example, with www in the URL), you can include the alternate names in your virtual host file by adding a ServerAlias Line. The beginning of your virtual host file would then look like this:

<VirtualHost *:80>
        ServerAdmin webmaster@example.com
        ServerName example.com
        ServerAlias www.example.com
  [...]

The next step is to fill in the correct Document Root. For this section, write in the extension of the new directory created in Step One. If the document root is incorrect or absent you will not be able to set up the virtual host.
The section should look like this:

 DocumentRoot /var/www/example.com/public_html

You do not need to make any other changes to this file. Save and Exit.
The last step is to activate the host, with the built in apache shortcut:

 sudo a2ensite example.com

Step Six—Restart Apache

We’ve made a lot of the changes to the configuration, and the virtual host is set up. However none of the changes that we made will take effect until Apache is restarted. Use this command to restart apache:

 sudo service apache2 restart

You may see an error along the lines of

Could not reliably determine the server's fully qualified domain name, using 127.0.0.1 for ServerName

The message is just a warning, and you will be able to access your virtual host without any further issues.

Optional Step Seven—Setting Up the Local Hosts

If you have pointed your domain name to your virtual private server’s IP address you can skip this step—you do not need to set up local hosts. Your virtual hosts should work. However, if want to try out your new virtual hosts without having to connect to an actual domain name, you can set up local hosts on your computer alone.

For this step, make sure you are on the computer itself, not your droplet.

To proceed with this step you need to know your computer’s administrative password, otherwise you will be required to use an actual domain name to test the virtual hosts.

If you are on a Mac or Linux, access the root user (su) on the computer and open up your hosts file:

nano /etc/hosts

If you are on a Windows Computer, you can find the directions to alter the host file on the Microsoft site

You can add the local hosts details to this file, as seen in the example below. As long as that line is there, directing your browser toward, say, example.com will give you all the virtual host details for the corresponding IP address.

# Host Database
#
# localhost is used to configure the loopback interface
# when the system is booting.  Do not change this entry.
##
127.0.0.1       localhost

#Virtual Hosts 
12.34.56.789    example.com

However, it may be a good idea to delete these made up addresses out of the local hosts folder when you are done to avoid any future confusion.

Step Eight—RESULTS: See Your Virtual Host in Action

Once you have finished setting up your virtual host, you can see how it looks online. Type your ip address into the browser (ie. http://12.34.56.789)

It should look somewhat similar to my handy screenshot

Good Job!

Creating More Virtual Hosts

To add more virtual hosts, you can just repeat the process above, being careful to set up a new document root with the appropriate domain name, and then creating and activating the new virtual host file.

Fuente: How To Set Up Apache Virtual Hosts on Ubuntu 12.04 LTS

Agrandar un disco virtual de VirtualBox (vmdk o vdi)

2013-11-13T12:31:00.000-03:00

Para ampliar (agrandar) un disco virtual de VirtualBox (usualmente vmdk o vdi) debemos proceder así:
a.- Si esta en vmdk lo primero es convertirlo en vdi. esto se hace desde la consola así:
VBoxManage clonehd –format VDI XP1.vmdk Windows_XP.vdi
b.- Comprobamos las características del nuevo disco clonado en formato vdi con:
VBoxManage showhdinfo Windows_XP.vdi
La salida muestra esto:

golgito:/home/tonisoto/VirtualBox/XP1# VBoxManage showhdinfo Windows_XP.vdi
UUID: 3c263693-9bad-4ebf-8cd9-0755cb9f0139
Accessible: yes
Logical size: 3500 MBytes
Current size on disk: 1827 MBytes
Type: normal (base)
Storage format: VDI
Format variant: dynamic default
In use by VMs: XP1 (UUID: 21556a50-df2c-4a05-8a56-b294ade3f5e8)

Location: /home/tonisoto/VirtualBox/XP1/Windows_XP.vdi

c.- Luego aumentamos el tamaño del disco físico al tamaño deseado así:

VBoxManage modifyhd Windows_XP.vdi –resize 10240

Ahora ya mostrará esto:

golgito:/home/tonisoto/VirtualBox/XP1# VBoxManage showhdinfo Windows_XP.vdi

UUID: 3c263693-9bad-4ebf-8cd9-0755cb9f0139

Accessible: yes

Logical size: 10240 MBytes [Aumentó el tamaño]

Current size on disk: 1699 MBytes

Type: normal (base)

Storage format: VDI

Format variant: dynamic default

In use by VMs: XP1 (UUID: 21556a50-df2c-4a05-8a56-b294ade3f5e8)

Location: /home/tonisoto/VirtualBox/XP1/Windows_XP.vdi

d.- Ahora tenemos que añadir este disco (Windows_XP.vdi) al anterior con el el que arrancábamos en Virtualbox (XP1.vdi) colocándolo como IDE Primario esclavo:

IDE primario maestro: XP1.dvi (en realidad ya podríamos eliminarlo y poner aquí el Windows_XP.dvi)

IDE Primario esclavo: Windows_XP.vdi

e.- Bajamos la ISO del Gparted-Live y configuramos el arranque del CD/DVD-ROM en primer lugar (luego el Harddisk) y para no tener que quemar la ISO del Gparted configuramos el CD en ‘Almacenamiento’ para que cargue esa ISO desde la carpeta del host donde está.

f.- Arrancamos de nuevo el Windows XP en virtualbox y se cargará el Gparted. Nos mostrá los discos conectados. Hacemos un ‘Resize’ del Windows_XP.vdi para que ocupe todo el tamaño disponible. Nos aseguramos que tiene la etiqueta (flag) de boot y salimos de Gparted.

g.- Ya está. Sólo queda dejar como maestro el nuevo :

IDE Primario maestro: Windows_XP.vdi

Cambiar el orden de arranque a: 1º Harddisk 2º CD/DVD-ROOM

Eliminar la vinculación del CD/DVD-ROOM a la ISO del Gparted y en su lugar vincularlo a la lectora

Borrar los *vdi’ que no utilicemos para que no ocupen espacio.

Actualizar lo necesario y tomar una instantánea.

Objetivo conseguido!

Fuente: http://www.tonisoto.com/?p=29

Backup incremental con Git

2012-02-28T17:27:00.000-03:00

Una forma realmente interesante de realizar backups de tus bases de datos (por ser trivial y muy potente) es usando Git. El proceso es simple y se basa en la realización de los dumps de la base de datos de forma que cada fila de las tablas sea un insert aislado, de esa forma en cada commit solo estaremos salvando las diferencias respecto al último estado (tanto deletes como inserts, como updates).

En el caso concreto de MySQL inicialmente haríamos algo como esto:

$ mkdir mydatabase && cd mydatabase
$ mysqldump --skip-extended-insert > data.sql
$ git init
$ git add data.sql
$ git commit -m "Initial dump of mydatabase"

A partir de entonces podemos automatizar el proceso con un script tan simple como este:

$ cat /usr/bin/git_backup_database
#!/bin/sh
BACKUP_DIRECTORY=$1
DATABASE=$2
 
cd $BACKUP_DIRECTORY && \
mysqldump --skip-extended-insert $DATABASE > data.sql && \
git commit -am "Updating dump `date +%Y_%m_%d__%H_%M`"

Según el volumen de consultas que tenga tu base de datos, te será interesante ponerlo en cron con una frecuencia determina u otra. Adicionalmente sería recomendable ejecutar $ git gc para optimizar el repositorio. Por ejemplo, dos veces al día y una vez a la semana mantenimiento:

0 0 * * * /usr/bin/git_backup_database /path/to/mydatabase mydatabase
0 12 * * * /usr/bin/git_backup_database  /path/to/mydatabase mydatabase
0 1 * * 1 cd /path/to/mydatabase && git gc

Además desde otro equipo nadie te impide hacer un $ git clone ssh://equipo:path/to/mydatabase y tener todo el historial de la base de datos en un plis (bueno eso es relativo, que ocupará lo suyo...) o incluso programar un $ git pull para tener varios backups en distintas maquinas. En definitiva, se abren un sinfín de opciones.

Fuente

Conexiones a MySQL desde PHP

2010-12-09T21:01:00.009-03:00

¿Qué es la Extensión MySQL de PHP?

Esta es la extensión original que interactúa con bases de datos MySQL. La extensión mysql proporciona una interfaz procedural. Pensada para usar sólo con versiones de MySQL anteriores a la 4.1.3. Se puede utilizar con versiones de MySQL > 4.1.3 no estarán disponibles todas las nuevas funcionalidades de MySQL.

¿Qué es la extensión mysqli de PHP?

La extensión mysqli, o como a veces se le conoce, la extensión de MySQL mejorada, se desarrolló para aprovechar las nuevas funcionalidades encontradas en los sistemas MySQL con versión 4.1.3 o posterior. La extensión mysqli viene incluida en las versiones PHP 5 y posteriores.

Vamos a necesitar crear nuestra base de datos, tablas y registros. Para eso tenemos el siguiente script:

-- Creamos la base de datos
CREATE DATABASE  `blog` ;

-- Creamos una tabla autores
-- Clave primaria: id
-- Ademas al campo 'autor' solo permitiremos valores unicos

CREATE TABLE  `blog`.`autores` (
 `id` INT NOT NULL AUTO_INCREMENT ,
 `autor` VARCHAR( 128 ) NOT NULL ,
 PRIMARY KEY (  `id` ) ,
 UNIQUE (`autor`)
) ENGINE = MYISAM ;


-- Creamos la tabla entradas

CREATE TABLE  `blog`.`entradas` (
 `id` INT NOT NULL AUTO_INCREMENT ,
 `titulo` VARCHAR( 256 ) NOT NULL ,
 `contenido` TEXT NOT NULL ,
 `autor_id` INT NOT NULL ,
 `fecha` DATETIME NOT NULL ,
 PRIMARY KEY (  `id` ) ,
 UNIQUE (`titulo`)
) ENGINE = MYISAM ;


-- Insertamos un par de autores
INSERT INTO  `blog`.`autores` (`autor`) VALUES ('Luis Mender');
INSERT INTO  `blog`.`autores` (`autor`) VALUES (  'Juan Perez');

-- Insertamos registros en la tabla entradas
INSERT INTO  `blog`.`entradas` (`titulo`, `contenido`,`autor_id`,`fecha`) VALUES ('Segundo Post', 'Contenido del segundo post',1,TIMESTAMP());
INSERT INTO  `blog`.`entradas` (`titulo`, `contenido`,`autor_id`,`fecha`) VALUES ('Tercer Post', 'Contenido del tercer post',1,TIMESTAMP());
INSERT INTO  `blog`.`entradas` (`titulo`, `contenido`,`autor_id`,`fecha`) VALUES ('Cuarto Post', 'Contenido del cuarto post',2,TIMESTAMP());

Con la sentencia

TIMESTAMP()

lo que haces es imprimir en el campo la fecha y hora de creacion del registro.

Ahora podremos hacer consultas a nuestra base de datos 'blog':

// Creamos un objeto con el recurso a mysql, de la clase mysqli
$conexion = new mysqli('localhost','root','password','blog');

// Hacemos una consulta, y esta nos devuelve
// un objeto de la clase mysqli_result
$resultado = $conexion->query("select * from entradas");

/* array */
$filas = $resultado->fetch_array(MYSQLI_NUM);
echo "<pre>";
print_r($filas);

/* associative array */
$filas = $resultado->fetch_array(MYSQLI_ASSOC);
echo "<pre>";
print_r($filas);

/* associative and numeric array */
$filas = $resultado->fetch_array(MYSQLI_BOTH);
echo "<pre>";
print_r($filas);

/* liberamos la memoria */
$resultado->close();

/* Cerramos la conexion */
$conexion->close();

Ejemplo: Visualizamos datos extra como la cantidad de filas devueltas y filas afectadas.
Realizamos un bucle para acceder a cada fila y poder extraer la informacion.

// Habilitamos todos los errores y advertencias
error_reporting(E_ALL);

$conexion = new mysqli("localhost", "root", "password", "blog");

/* verificar conexion */

// Controlamos el numero de error
if (mysqli_connect_errno()) {
// Visualizamos la descripcion del error
echo "Error enconexion: ". mysqli_connect_error();
exit();
}

// Creamos la consulta
$sql = "SELECT * FROM entradas";

// Hacemos la consulta
$resultado = $conexion->query($sql)
// Si la consulta fue exitosa:
if ($resultado) {

 /* fetch array asociativo*/
 // Por cada fila mostramos el contenido del campo titulo
 while ($fila = $resultado->fetch_assoc()) {
  echo $fila["titulo"].'
';
 }
        // Mostramos el numero de filas afectadas que genera la consulta
 echo "El numero de filas afectadas es: ". $conexion->affected_rows . "
";
        // Mostramos la cantidad de filas devuelta por la consulta
 echo "El numero de filas devueltas es: ". $resultado->num_rows;
 
 /* liberamos la memoria asociada al resultado */
 $resultado->close();
}

/* cerramos la conexion */
$conexion->close();

Ejemplo de inserción en una tabla: Además obtenemos el último id generado. Esto siempre y cuando en mysql el campo id sea AUTO INCREMENT.

$sql = "INSERT INTO autores (`autor`) VALUES ('juan3')";

if ($resultado = $conexion->query($sql)) {
 echo "El id creado es: ". $conexion->insert_id;
 echo "Filas afectadas : ". $conexion->affected_rows;
}else
 echo "Hubo un error ".$conexion->errno." - ".$conexion->error;

/* cerramos la conexion */
$conexion->close();

Ahora un ejemplo de creacion de Base de datos:

$sql = "CREATE DATABASE test2 ;";

// Esta sentencia es para borrar la base de datos.
//$sql = "DROP DATABASE test2 ;";

if ($resultado = $conexion->query($sql)) {

 echo "Filas afectadas : ". $conexion->affected_rows;
}else
 echo "Hubo un error ".$conexion->errno." - ".$conexion->error;

/* cerramos la conexion */
$conexion->close();

Un último ejemplo de como obtener informacion de la tabla: Tipo de datos que tiene cada campo, que flags tienen cada campo (UNIQUE, AUTO INCREMENT, NOT NULL) Esta informacion puede ser útil a la hora de generar formularios automáticamente.

$query = "SELECT * from entradas";

// get the result from the DB


if ($result = $conexion->query($query)) {

    /* Get field information for all columns */
    $finfo = $result->fetch_fields();

    foreach ($finfo as $val) {
     echo "Name ".$val->name."
";
     echo "Table ".$val->table."
";
     echo "max. Len ".$val->max_length."
";
     echo "Flags ".$val->flags."
";
     echo "Type ".$val->type."
";
    }
    $result->close();
}

Ejemplo Arrays

2010-11-13T05:14:00.005-03:00

Un array es una collecion de elmenetos. Es una de las estructuras de datos mas importantes de los lenguajes de programacion. A diferencia de otros lenguajes como C/C++ los vectores (asi se llaman es estos otros lenguajes) solo permiten arreglos/vectores con indices numérico.

PHP nos permite crear ademas de un vector/arreglo ordinario, un arreglo asociativo, que consta en un arreglo de elementos 'clave->valor'. La clave o key es un string que identifica al elemento.

Al tener key's ya no podemos usar los bucles while/for ya que su 'indice' (en este caso key) no se lo puede recorrer con un indice al que en cada vuelta lo aumentamos uno en uno.

Para eso usaremos el bucle foreach, que es exclusivo para array.

Un ejemplo es:

$mi_array = array('Luis','Carlos','Andrea','Maria');
  foreach ($mi_array as $clave => $valor){
  echo "Elemento 1: $clave => $valor";
}

Como tambien veremos que podemos anidar los elementos de un array, con otros array. Veamos:

$alumno1 = array('Juan','Perez',20);
$alumno2 = array('Jose','Gonzalez',21);
$alumno3 = array('Carlos','Garcia',22);
$alumno4 = array('Maria','Alvarez',23);
$mis_alumnos(
  'lu01' => $alumno1,
  'lu02' => $alumno2,
  'lu03' => $alumno3,
  'lu04' => $alumno4
  );

$tabla = crearTabla($mis_alumnos);

echo $tabla;

Definamos crearFila():

$filaTemplate = "<tr>{celdas}</tr>";  
$celdaTemplate = "<td>{dato}</td>";
$encabezadoTablaTemplate="<th>{dato}</th>";
/* Pasamos un arrar de 1 dimensio */
function crearFila($datos){  
    global $filaTemplate;  
    global $celdaTemplate ; 
  // Creamos unas plantillas para las filas y las celdas  
   
  // Creamos un string vacio donde acumularemos las celdas  
  $celdas = '';  
  // Creamos el html de las celdas, con el template de la celda  
  if(count($datos)>0 && is_array($datos)){  
    foreach($datos as $dato)  
      // Reemplazamos {dato}  
      $celdas .= str_replace('{dato}',$dato,$celdaTemplate); // vamos concatenando con lo existente  
  } 
  //Ahora reemplazamos en la fila  
  $fila = str_replace('{celdas}',$celdas,$filaTemplate);  

  return $fila;
}  
  
function crearTabla($tabla){  
  global $filaTemplate;
  global $encabezadoTablaTemplate;
  $inicioTabla = "<table>";  
  $finTabla = "</table>";
  $filas ="";
  $columnas='';
  //Recorremos la tabla  
  foreach($tabla as $libreta => $alumno){
    if($columnas=='')
        $columnas= array_keys($alumno);
    array_unshift($alumno,$libreta) ; 
    $filas .= crearFila($alumno)."\n"  ;
  }
  array_unshift($columnas,'libreta');
  
  //Crear encabezado
  $encabezadoCelda="";
  foreach($columnas as $columna){
      $encabezadoCelda .= str_replace('{dato}',strtoupper($columna),$encabezadoTablaTemplate);
  }
  
  $encabezado= str_replace('{celdas}',$encabezadoCelda,$filaTemplate);
  return $inicioTabla.$encabezado."\n".$filas.$finTabla;  
}

Ejemplos de formularios

2010-11-13T05:04:00.008-03:00

Voy a dar unos ejemplos de formulario. En cuanto a este tema hay mucha tela para cortar.

<input name="vehicle" type="checkbox" value="Car" /> I have a car

<form action="html_form_action.asp" method="get" name="input">
Username: <input name="user" type="text" />
<input type="submit" value="Submit" />
</form>

<form action="">
<select name="cars">
<option value="volvo">Volvo</option>
<option value="saab">Saab</option>
<option value="fiat">Fiat</option>
<option value="audi">Audi</option>
</select>
</form

<select name="cars">
<option value="volvo">Volvo</option>
<option value="saab">Saab</option>
<option selected="selected" value="fiat">Fiat</option>
<option value="audi">Audi</option>
</select>

<textarea cols="30" rows="10">The cat was playing in the garden.
</textarea>

<input type="button" value="Hello world!" />
</form>

<input type="reset" value="Clear the Form" />

Seminario Optimizacion y performance LAMP

2010-05-30T20:02:00.010-03:00

Los invito a participar en este seminario que se realizara en la Facultad de Ciencias Exactas de la U.N.T. (Av. Independencia 1800) en el Anfiteatro A2.

Requisitos recomendados: Nociones básicas de Linux (instalación de aplicaciones), Apache, PHP y MySQL.

Fecha y horario: Viernes 18 de Junio de 2010. 15 hs.

Duración: 5 hs.

Lugar: Anfiteatro A2. Facultad de Ciencias Exactas y Tecnología. Universidad Nacional de Tucumán.

Página web: http://www1.herrera.unt.edu.ar/cursos_extension/

Objetivos del seminario

Al finalizar el seminario, los asistentes tendrán los conceptos teóricos y prácticos fundamentales sobre configuración y optimización para lograr una mejor performance en servidores web Apache con base de datos MySQL y con el lenguaje de programación PHP sobre servidores GNU/Linux. La combinación de estas tecnologías, también conocida por el acrónimo LAMP, es la plataforma Open Source para construir un servidor web más usado, e implementado en muchos de los sitios más importantes de Internet como ser Yahoo!, Wikipedia, Youtube, Facebook, entre otros.

Temario Resumido

El seminario estará organizado según los temas siguientes:

Descripción del stack LAMP. Consideraciones generales
Penetración en el medio de IT
Elección del File System - performance
Apache, consideración de seguridad y optimización
Modulos de Apache para multiprocesamiento
PHP y tecnologías de "caching" para optimización
MySQL, configuración de parámetros del DBMS
Optimización de MySQL desde el punto de vista del motor DB
Test performance MySQL
Test de performance del stack LAMP
Monitoreo y disponibilidad de servidores LAMP

Costo:

Miembros de UNT OSUM: 40$
Público en general: 60$

El pago se deberá realizar en Asociación Cooperadora de la FACET

(Av. Independencia 1800 – Block Decanato) de Lunes a Viernes de 8.00 a 12.00 hs.

Más información: http://www1.herrera.unt.edu.ar/cursos_extension/

Se entregará material y certificado de asistencia

Si querés ser parte de UNT OSUM, registrate en:

http://osum.sun.com/group/UNTOSUM

Se vienen las 2da Mini-Charlas, Tucuman Valley

2010-05-17T21:00:00.003-03:00

El 2º ciclo de Minicharlas será para este próximo jueves 20 de Mayo a horas 20:00 en la Fundación del Tucumán.
Los temas a tratar serán:

Cloud Computing
Ruby on Rails

Pueden consultar mas informacion aquí: http://www.tucumanvalley.com/2010/05/17/2da-minicharla-tucuman-valley-temas-y-expositores/

Sesiones y subdominios en PHP

2010-05-03T20:16:00.011-03:00

Alguna ves programando me tope con subdominio y sessiones.

El tema es que si iniciaba sesion poniendo http://misitio.com/ la sesion no valia, por ejemplo, para algun subdominio http://misubdominio.misitio.com/

El problema se resuelve rapidamente con setear a PHP correctamente para que las sesiones las cree para un dominio en general.

Hacemos al principio del script que se ejecutara en el subdominio:

ini_set("session.cookie_domain",".misitio.com");

No es necesarios que en los script que se ejecutaran en el dominio lleven eso, pero si en los scripts que se ejecutaran con un subdominio.
Esto hacemos en las paginas donde accedemos con un subdominio.

Mas informacion sobre ini_set(); en: http://www.php.net/manual/es/function.ini-set.php

Mi blog.

2009-10-01T13:06:00.002-03:00

Bueno tome la iniciativa, empeze con mi blog. Lo hice en Blogger ya que deseaba probar primero antes de pagar mi propio espacio.
Mi nombre es Luis, y estudio Ingeniería en Computacion en la Universidad Nacional de Tucumán.
Creo que principalmente en este espacio postearé temas sobre desarrollo, especificamente Web. Pero quizás también, temas de Internet en general, Social Media, quizás tecnología, todo lo que me guste y pueda compartirlo con Uds.