Social Icons

sábado, 29 de octubre de 2011

Como instalar PHP, Mysql y Apache en Ubuntu

Contamos con otra versión de este post aquí.

*) Primero instalamos apache con la siguiente orden:
-----------------------------------------------------------------
sudo apt-get install apache2
-----------------------------------------------------------------

*) Después debemos instalar php con la orden:
-----------------------------------------------------------------
sudo apt-get install php5                                        
-----------------------------------------------------------------

*) Instalamos las librerias que permitiran interaccion entre MySql, apache y php:
-----------------------------------------------------------------
sudo apt-get install libapache2-mod-auth-mysql php5-mysql
-----------------------------------------------------------------

*) Instalar MySql server 5 o MySql 4.1, según prefieran:
----------------------------------------------------------------
MySql 5 : sudo apt-get install mysql-server-5.

MySql 4.1 : sudo apt-get install mysql-server-4.1
----------------------------------------------------------------

*) Reiniciamos los servicios para ponerlos a prueba:
---------------------------------------------------------------
sudo /etc/init.d/apache2 restart

sudo /etc/init.d/mysql restart
---------------------------------------------------------------

*) Ponemos a prueba que todo funcione:
- Primero abrimos nuestro navegador y ponemos en la barra de dirección:

http://localhost/

Tiene que aparecer un mensaje como:

It works!

-) Comprobamos que MySql funciona escribirndo en la terminal:

mysql -u root

debería salirnos un mensaje de bienvenida y la etiqueta de la línea de órdenes, es decir,

mysql>
Si hemos puesto password durante la instalación es posible que necesitemos introducirlo en esta prueba, por lo que ejecutaremos en consola la orden:

mysql -u root -p

y ahora se nos pedirá el password, que escrito correctamente nos llevará a un mensaje de bienvenida y la línea:

mysql>

-) Comprobar que php funcione:

Para esto primero debemos dar permisos a la carpeta www escribiendo en la terminal:

sudo chmod 777 -R /var/www/

Después abriremos nuestro editor de texto y escribiremos:

    <?

    echo ” que onda wey?”;

    phpinfo();

    ?>

Esto lo guardamos en la carpeta "/var/www/" con el nombre que nosotros queramos pero con la extensión ".php"

Ya, por fin, iremos a "localhost/el_nombre_que_hayamos_puesto.php"

-----------

Tamaños de archivos a descargar:
*php: (7766kB)

*msql, apache, php: Necesitarán descargar 0B/64,2kB de archivos. Después de desempaquetar se liberarán 426kB.

Y ... esto es todo por hoy.

domingo, 23 de octubre de 2011

GHCi, version 7.0.3 no admite el patrón (n+k) en las definiciones de funciones

Introducción

Con las versiones de Haskell provistas en los Ubuntu anteriores a Ubuntu 11.10, los programadores de Haskell han venido usando un truco permitido, aunque no muy ortodoxo, que era incluir el patrón (n+k) en las definiciones de funciones, a la izquierda del igual definitorio. Por ejemplo, la implementación del factorial era entendida por muchos así:

factorial :: Integer -> Integer
factorial 0 = 1
factorial (n+1)  =  (n+1) * factorial n

en lugar de:

fact :: Integer -> Integer
fact 0 = 1
fact n  =  n * fact (n-1)

El lector se preguntará intrigado por la diferencia entre factorial y fact. Es muy sutil, tanto que ni algunos desarrolladores la captan ... y todo se debe a un comportamiento sui géneris  del intérprete/compilador. Resulta que al intentar calcular factorial (-1) el diálogo que se producía antes, por ejemplo bajo GHCi version 6.10.4, era:

*Main> factorial (-1)
*** Exception: factorial.hs:(2,0)-(3,36): Non-exhaustive patterns in function factorial


*Main> fact (-1)
*** Exception: stack overflow

Explicación

Con fact ocurre lo siguiente:

fact (-1)  = (-1) * fact (-2)
           = (-1) * (-2) * fact (-3)
           = etc ... por siempre


Con factorial ocurría algo distinto. Al intentar calcular factorial (-1) el intérprete busca si (-1) unifica con el argumento de la primera línea, y esto no ocurre porque -1 es distinto de 0; así pués intenta ver si (-1) unifica con (n+1) para algún valor de n, pero en las antiguas versiones (n+k), con k natural fijo pero arbitrario, únicamente unificaba con valores enteros superiores o iguales a k. Por tanto, (-1) no unificaba con el patrón de ninguna de las líneas definitorias de factorial y, siendo -1 una instancia del tipo Integer, la definición de factorial debería estar incompleta, de ahí el mensaje "Non-exhaustive patterns in function factorial".

Total, lo que hacía el programador era optimizar el esfuerzo al escribir código y conjurar el peligro de caer en un bucle infinito, promoviendo una definición incompleta cuya excepción siempre se podría capturar.

Los desarrolladores, creemos que con buen criterio, han impedido estas estratégias y han impedido definiciones como la de factorial en beneficio de definiciones como las de fact. De hecho, si con GHCi, version 7.0.3 intentamos interpretar un fichero que contuviera a factorial, se produciría un error como el siguiente:


$ ghci factorial.hs
GHCi, version 7.0.3: http://www.haskell.org/ghc/  :? for help
Loading package ghc-prim ... linking ... done.
Loading package integer-gmp ... linking ... done.
Loading package base ... linking ... done.
[1 of 1] Compiling Main             ( factorial.hs, interpreted )

factorial.hs:3:12: Parse error in pattern: n + 1
Failed, modules loaded: none.
Prelude> 

donde se dice explícitamente que no admite el patrón (n+1). 

Problema

Creemos que lo adecuado y aconsejable es programar sin el patrón (n+k) dando definiciones exhaustiva, con mensajes de error cuando sea conveniente; pero ... ¿qué hacemos con lo ya programado? 

Para programas antiguos concebidos con esas estratégias,  programas que no estamos dispuestos a modificar pues podría suponer un gran esfuerzo: ¿qué solución hay, si la hay?

Solución

Pues sí la hay y ... la hemos encontrado. Mejor dicho, conocemos dos soluciones:

a) La primera sería incluir en la cabecera del fichero el siguiente texto:

-- posible comentario
 {-# LANGUAGE NPlusKPatterns #-}
 module Main where

con lo que quedaría

-- posible comentario
 {-# LANGUAGE NPlusKPatterns #-}
 module Main where


factorial :: Integer -> Integer
factorial 0 = 1
factorial (n+1)  =  (n+1) * factorial n
...

que sería admitido por el nuevo ghci sin error. No es necesario poner aquí  "Main" en "module Main where", podríamos haber puesto otro nombre, pero dejo este para sugerir que podríamos estar ante el módulo "main" de un proyecto, que podría ser compilado también con ghc.

b) Al compilar el fichero factorial.hs que contiene, o llama, a la función factorial, haríamos lo siguiente:

$ ghci -XNPlusKPatterns factorial.hs

Creemos que también funciona

$ ghc  -XNPlusKPatterns .... factorial.hs

En realidad, cualquiera de las dos soluciones lo que hace es forzar al intérprete/compilador de Haskell a volver al pasado, volver a los esquemas que sí admitían el patrón definitorio (n+k).

Y ... esto es todo por hoy.




lunes, 17 de octubre de 2011

Instalación y uso básico de dosemu

Introducción

dosemu es una utilidad similar a DosBox que hoy por hoy sólo está disponible para Linux.  Nos permite hacer lo mismo que DosBox, por lo que no hay nada que añadir a la introducción hecha en nuestro post de DosBox.

Entonces, ¿podemos prescindir de dosemu? La respuesta es negativa; hemos constatado que hay múltiples  ejecutables hechos para MS-Dos que funcionan mejor en dosemu, al menos en algunos de sus rasgos. Lo ideal es tener en nuestro Ubuntu una instalación de DosBox y otra de dosemu para usar en cada caso lo que mejor nos venga.

Instalación

Suponemos instalada la versión preferida de Ubuntu y plena capacidad de uso de apt-get. En este caso ejecutamos desde la línea de órdenes de una terminal:

sudo apt-get install dosemu
cuando termine el proceso ejecutamos desde la misma línea de órdenes:

dosemu
Si tenemos poca memoria RAM en el equipo, lo normal es que falle esta orden; pero no hay que preocuparse. En caso de fallo ejecutamos desde la línea de órdenes:

sudo sysctl -w vm.mmap_min_addr=0
Se ejecuta una vez por sesión y antes de ejecutar dosemu.

Una vez se ha conseguido ejecutar dosemu la primera vez, es generado el directorio oculto

/home/mi_usario/.dosemu
que será el directorio de trabajo. En DosBox cualquier directorio del ordenador podía ser nuestro directorio de trabajo. A diferencia, en dosemu todo lo que deseemos ejecutar tendrá que estar situado en .dosemu

Para poder ir hasta él con el navegador interno Nautilus, haremos Ctrl+h desde él y ya  tendremos a nuestra vista y alcance el directorio de trabajo .dosemu, entre otros.


Uso de dosemu

Si entramos en el directorio /home/mi_usuario/.dosemu veremos  una carpeta o directorio llamado

drive_c
Todos los programas que queramos usar, deberán ser colocados en éste directorio drive_c. Sugerimos colocarlos ordenados en subdirectorios de este directorio de trabajo. Recordamos que en MS-Dos muy poco se instalaba, aunque lo que se instalaba también se podrá instalar en dosemu, tal y como hacíamos allí. Ahora cada vez que queramos ejecutar uno de nuestros programas, iremos al directorio .dosemu, lo buscaremos en él o entre sus carpetas y lo ejecutaremos en el modo habitual.

Nota Final

Recomendamos usar junto a dosemu  la famosa reimplementación  de la interfaz de programación de aplicaciones de Win16 y Win32 para sistemas operativos basados en Unix,  que se conoce con el nombre de wine (acrónimo recursivo en inglés para  Wine Is Not an Emulator, que significa "Wine no es un emulador" y que inicialmente fue un acrónimo para WINdows Emulator).

Y ... esto es todo por hoy.