SQLeros

Solución al Error: Kernel driver not installed (rc=-1908) en OpenSUSE

2014-04-14T23:35:00.000-05:00

Bueno amigos SQLeros, ahora les traigo una solución a este error:

Kernel driver not installed (rc=-1908)
The VirtualBox Linux kernel driver (vboxdrv) is either not loaded or there is a permission problem with /dev/vboxdrv. Re-setup the kernel module by executing
'/etc/init.d/vboxdrv setup'
as root. Users of Ubuntu, Fedora or Mandriva should install the DKMS package first. This package keeps track of Linux kernel changes and recompiles the vboxdrv kernel module if necessary.

Tengo en mi lap un OpenSUSE 13.1 y bueno como saben, aveces es necesario tener más SSOO instalados en la computadora para hacer pruebas. Bueno cuando instale VirtualBox en mi lap, todo bien pero al intentar correr las maquínas virtuales que tenía en mi disco de Respaldo, puff mandaba error... Bueno entonces abrimos una terminal y escribimos:

sudo zypper install gcc make automake autoconf kernel-source

Nos descargará varios utilidades para re-compilar el kernel y poder tener la funcionalidad de virtualización activa. Tardará unos momentos de acuerdo a su velocidad de descarga. Una vez descargada, se instalará.

Reiniciamos la computadora y ... Casi esta listo! Porque sigue mandando el mismo error; bueno ahora nos resta ejecutar el comando que nos comenta el mensaje. En este caso es:

/etc/init.d/vboxdrv setup

Iniciamos la aplicación y listo... Espero les sea de utilidad, un Saludo y hasta la próxima.

Solución: Aplicaciones se cierran en windows 8 inesperadamente

2013-09-12T23:41:00.000-05:00

Éste es un problema que con suerte solo pudieron evidenciar quienes tengan Windows 8 y Avast corriendo sobre el mismo abran podido evidenciar que las aplicaciones que usan el estilo “Moderno” y necesiten de Internet se cierran luego de abrirlas, y como pudieron intuir hasta este punto, es culpa del Avast.

Pasa que el Avast es tan “completo” que piensa que el código ejecutado por estas aplicaciones no es seguro y las cierra, para solucionar eso, solo debemos:
Abrir la ventana principal de Avast.

Ir a la opción de la pestaña Antivirus.

Seleccionar escudo de comportamiento.

En la sección de este escudo, seleccionamos opciones.

Y por ultimo, des-tildamos “monitorizar el sistema en busca de modificaciones no autorizadas” (la ultima).

Aceptar y disfrutar.

¡Espero les sea de ayuda!

Al Servicio De La Comunidad: Erick Adrian Peña Alarcon

2013-09-04T16:39:00.000-05:00

Rubén Peña

Pues nada… aquí dejo una foto de mi hermano: Erick Adrian Peña Alarcón, no hemos sabido de el desde el domingo 1 de septiembre de este año. Actualmente se encuentra enfermo, solía ser maestro, es una buena persona… pero pues.. no sabemos qué es lo que le esta afectando… lo ultimo que hemos sabido de él es que se le ha visto por Llano de en medio, veracruz. hace dos dias. Si lo ves favor de detenerlo y avisarnos para que podamos finalmente encontrarlo. cualquier información favor de comunicarse con el numero 2351007856.

Crear USB MultiBoot Con XBOOT

2013-08-29T16:30:00.000-05:00

Gracias a la gran capacidad de las memorias de almacenamiento externo, particularmente los pendrives, es fácil llevar siempre con nosotros un completo sistema operativo en nuestra memoria USB. Pero XBOOT es una aplicación que va un poco más allá, ya que nos permite crear una unidad USB booteable con varios sistemas operativos y aplicaciones de rescate, antivirus, etc.

XBOOT es un software Open Source para Windows, que requiere tener previamente instalado .NET framework 4. Su uso es muy sencillo, sólo debemos arrastrar la imagen ISO sobre la ventana de esta aplicación y seleccionar la opción elegida.

Enlace | XBOOT
Vía | Error405

Generating Dummy Data for Testing

2013-08-22T10:56:00.002-05:00

Generating Dummy Data for Testing

I have worked on a number of projects where there hasn’t been enough data to test reports and extracts and other database applications. The database was a third party database and the vendor wouldn’t allow data to be entered via the back end. We didn’t have enough data to test response times or to tune SQL until after GO-Live. This caused a lot of rework after GO-Live which in turn affected the perception of quality of the project as a whole.

The purpose of this article is to provide a means of generating random data which can be inserted into a database for testing purposes.

The scripts and methodology allow sample data to be generated. The scripts below create a number of tables for storing different data descriptors, e.g. name, street type, number, transactions. Some tables are reused to generate street names and post codes.

If you wanted data that was only based on data type and had no other meaning you could classify the tables by data type; e.g. datetime, character and numeric.

Data is generated by creating Cartesian joins on the tables. Using the generated dataset this gives 8,000,000 (10 x 10 x 1000 x 4 x 20 x 1) rows of data. Id values are generated using a sequence. Child – Parent relationships are created by including the parent id in a Cartesian product with the child data (See below).

Diagram 1 - Populating the Application database

Diagram 2 - Use of Synonyms where changes to the application database are not allowed.

Architecture

The solution is broken into a number of layers. They are:

the Base Data Layer
the Reporting Data Layer

These layers can be within different schemas within the database.

Base Data Layer

The base data layer contains the dummy data tables, any data generation scripts, and a sequence or sequences for generating Ids.

Reporting Data Layer

This layer contains derived tables and views which create data similar to what would be seen in the application that you are testing. There may be a number of steps involved in getting data from the base tables into a format that can be imported into your application database.

If data cannot be created in the application database, create tables in the Reporting Data Layer and then create synonyms to them, populate the tables and use the synonyms for reporting. When the system goes live, point the synonyms to the application database. In this case, the Reporting Data Layer and Base Data Layers may be in a separate database to the application database.

How Cartesian joins work

A Cartesian join multiplies every row in a dataset with every row in the joined dataset. Imagine I have two tables with data as shown below:

First_Name Last_Name

=========== ===============

Bill S Preston Esq

Ted Theodore Logan

Attila the Hun Attila the Hun

SQL Server TSQL provides the CROSS JOIN which operates as a Cartesian join, unless you include a WHERE clause which links the two tables; e.g.

Case 1 Cartesian join

Select First_Name.Name + ' ' + Last_Name.Name Surname
 From  First_name
  Cross Join Last_Name

Result set

Surname

============

Bill S Preston Esq

Ted S Preston Esq

Attila the Hun S Preston Esq

Bill Theodore Logan

Ted Theodore Logan

Attila the Hun Theodore Logan

Bill Attila the Hun

Ted Attila the Hun

Attila the Hun Attila the Hun

Case 2 Inner join

Select First_Name.Name + ' ' + Last_Name.Name Surname
 From  First_name
  Cross Join Last_Name
 Where First_Name.Name = Last_Name.Name

Result set

Surname

========

Attila the Hun Attila the Hun

Case 3 Cartesian join with where clause

Select First_Name.Name + ' ' + Last_Name.Name Surname
 From  First_name
  Cross Join Last_Name
 Where First_Name.Name = ‘Attila the Hun’

Result set

Surname

===============================

Attila the Hun S Preston Esq

Attila the Hun Theodore Logan

Attila the Hun Attila the Hun

Creating the data

The attached scripts will generate the following database items:

Tables

There are 5 tables created with the names and rowcounts shown below.

Name	Rows
First_Name	10
Last_Name	10
Numbers	1000
Street_Types	4
Transactions	20

In addition, there is a function and a sequence needed.

Function

Random_Number

Sequences

dbo.Dummy

Step 1 Create a new database.

No TSQL is included here as nearly everyone’s hardware setup will be different. The database in this example is called Dummy_Data.

Step 2 Create Database Objects

These scripts create the objects listed above.

USE Dummy_Data
GO
CREATE TABLE dbo.First_Names(
 Name VARCHAR(250) NOT NULL PRIMARY KEY
)
GO
CREATE TABLE dbo.Last_Names(
 Name VARCHAR(250) NOT NULL PRIMARY KEY
)
GO
CREATE TABLE dbo.Numbers(
 Num SMALLINT NOT NULL PRIMARY KEY
)
GO
CREATE TABLE dbo.Street_Type(
 Street_Type VARCHAR(20) NOT NULL PRIMARY KEY
)
GO
CREATE TABLE dbo.Transactions(
 Date1 DATETIME NULL,
 Date2 DATETIME NULL,
 Amount1 MONEY NULL,
 Amount2 MONEY NULL,
 Amount3 MONEY NULL
)
GO
create sequence dbo.Dummy
 start with 1
 increment by 1
GO
CREATE FUNCTION Random_Number(@Lower INT, @Upper INT, @seed FLOAT)
 RETURNS INT
AS
BEGIN

 DECLARE @Random INT;

 SELECT @Random = ROUND(((@Upper - @Lower -1) * @Seed + @Lower), 0)

 RETURN @Random

END
GO

Step 3 Populate Names Data

Next we need to insert data into these tables that will be used to generate our other data. Please feel free to modify these values as needed.

INSERT INTO First_Names VALUES('Bill')
INSERT INTO First_Names VALUES('Bob')
INSERT INTO First_Names VALUES('Buffy')
INSERT INTO First_Names VALUES('Ethan')
INSERT INTO First_Names VALUES('Jamie')
INSERT INTO First_Names VALUES('John')
INSERT INTO First_Names VALUES('Kevin')
INSERT INTO First_Names VALUES('Lee')
INSERT INTO First_Names VALUES('Lincoln')
INSERT INTO First_Names VALUES('Megan')
GO
INSERT INTO Last_Names VALUES('Blutofski')
INSERT INTO Last_Names VALUES('Brown')
INSERT INTO Last_Names VALUES('Fitz-Waller')
INSERT INTO Last_Names VALUES('Fluffy')
INSERT INTO Last_Names VALUES('Grey')
INSERT INTO Last_Names VALUES('Guinea-Pig')
INSERT INTO Last_Names VALUES('Holmes')
INSERT INTO Last_Names VALUES('Whalloper')
INSERT INTO Last_Names VALUES('Ingram')
INSERT INTO Last_Names VALUES('Bonkers')
GO
INSERT INTO street_type VALUES ('Drive')
INSERT INTO street_type VALUES ('Place')
INSERT INTO street_type VALUES ('Road')
INSERT INTO street_type VALUES ('Street')
GO

Step 4 Populate Numbers Table

The numbers table can fulfil a number of uses. The data in this table has been limited to 1000 entries, but you can change that if you feel the need. This script populates the table with consecutive numbers

DECLARE @iVal INT
BEGIN
 SET @iVal = 1;
 WHILE @iVal <= 1000
  BEGIN
   INSERT INTO Numbers VALUES(@iVal)
   SET @iVal = @iVal + 1
  END
END
GO

Step 5 Populate Transaction Data

The transaction data consists of two dates and three amounts. The first date occurs in the first half of the month and the second date occurs in the last half of the month. The three amounts have been determined at random. The second amount is 10% of the third amount, and the first amount = the second amount + the third amount. These numbers can be used to emulate sales values, profits etc.

The script to create this data is below.

BEGIN

DECLARE @ddate DATETIME
DECLARE @ddate2 DATETIME
DECLARE @amt MONEY
DECLARE @amt2 MONEY
DECLARE @amt3 MONEY
DECLARE @dollars INT
DECLARE @cents INT
DECLARE @year INT
DECLARE @month INT
DECLARE @day INT
DECLARE @iLoop INT

SELECT @iLoop = 1

WHILE (@iLoop <= 20)
 BEGIN
  --dates
  SELECT @day = dbo.Random_Number(1,14,Rand())
  SELECT @month = dbo.Random_Number(1,12,Rand())
  SELECT @year = dbo.Random_Number(2010,2013,Rand())
  SELECT @ddate = cast(cast(@month AS VARCHAR(2)) + '/' + CAST(@day AS VARCHAR(2)) + '/' + CAST(@year AS VARCHAR(4)) AS DATETIME)
  SELECT @day = dbo.Random_Number(15,28,Rand())
  SELECT @ddate2 = CAST(CAST(@month AS VARCHAR(2)) + '/' + CAST(@day as VARCHAR(2)) + '/' + CAST(@year AS VARCHAR(4)) AS DATETIME)

  --amounts
  SELECT @dollars = dbo.Random_Number(15,1000,RAND())
  SELECT @cents = dbo.Random_Number(0,99,RAND())
  SELECT @amt = CONVERT(MONEY,CAST(@dollars AS VARCHAR(4)) + '.'
  + RIGHT('00' + CAST(@cents AS VARCHAR(2)),2))
  SELECT @dollars = @amt /1.1
  SELECT @amt3 = CONVERT(MONEY,CAST(@dollars AS VARCHAR(4)) + '.' + RIGHT('00' + CAST(@cents AS VARCHAR(2)),2))
  SELECT @amt2 = @amt - @amt3

  INSERT INTO Transactions VALUES(@ddate,@ddate2,@amt,@amt2,@amt3)
  SELECT @iLoop = @iLoop + 1
 END --loop

END
GO

Step 6 Creating Names

This step uses a CROSS JOIN to create 100 names. The id is generated using the sequence.

SELECT NEXT VALUE FOR dbo.Dummy Id,
 fn.name First_Name,
 ln.name Last_Name,
 nm.Num Street_no,
 sn.Name as street_name,
 st.Street_Type
 INTO Customer_Data
 FROM first_names fn
  CROSS JOIN last_names ln
  CROSS JOIN numbers nm
  CROSS JOIN last_names sn
  CROSS JOIN street_type st

Step 7 Creating Transactions

This step uses a CROSS JOIN to populate a new table with transactions and IDs. The Ids will match the customer Ids. Every customer will end up with a full set of 20 transactions.

SELECT nd.Id,
       tr.*
  INTO Transaction_Data
 FROM Customer_Data nd
  CROSS JOIN Transactions tr

Conclusion

This article has highlighted three things:

The use of CROSS JOIN
- Without a where clause table A is multiplied by table B
- With a where clause that links the two tables the result is the same as an inner join
- With a where clause that limits the data in either table
Generating sample data by using CROSS JOIN
The use of synonyms to provide a level of abstraction to your reporting layer, remembering that any optimisation via indexes will still need to occur on the application database.

I hope this helps some of you.

Inspired by SQLServerCentral

Tips SQLeros: Validar sólo letras con JQuery

2013-07-08T12:25:00.002-05:00

Bueno mis estimados lectores les comparto un código para poder validar en la entrada de datos de un control input text, que solo acepte letras. En el document ready de jquery agregan la siguiente linea... :D Es casí el mismo código que este de validar números.

//Validar las cajas de texto...
$('input[type=text]').keypress(function (e) {
var tecla = document.all ? tecla = e.keyCode : tecla = e.which;
return !((tecla > 47 && tecla < 58) || tecla == 46);
});

Con esto todas las cajas de texto, sólo aceptaran como entrada letras.

Saludos!

Windows Server 2008: Politicas de Contraseña

2013-05-03T14:01:00.002-05:00

Por defecto, Microsoft Windows Server 2008 nos pide a los usuarios del grupo Administradores cumplir con utilizar contraseñas seguras. Los usuarios domésticos a menudo sólo quieren crear sus propias contraseñas o dejarlo en blanco sin cumplir ninguna de las políticas. Este tutorial se explica cómo deshabilitar estos requisitos de complejidad!

1.- Haga clic en Ejecutar en el menú Inicio, escriba gpedit.msc y luego haga clic enAceptar. En el Editor de directivas de grupo local expanda Configuración del equipo -> Configuración de Windows -> Configuración de seguridad ->Directivas de cuenta y haga clic en Directiva de contraseñas.

2.- En el panel derecho, haga clic doble contraseña debe cumplir los requisitos de complejidad y ponerlo a personas de movilidad reducida. Haga clic enAceptar para guardar los cambios. Ahora ya no se verán obligados a utilizar contraseñas seguras, incluso se puede usar una en blanco!

3.- Opcionalmente también se puede optar por no dejar que expiran sus contraseñas. Para ello, abra la vigencia máxima de la contraseña y el conjunto establecer el valor a 0. Haga clic en Aceptar para guardar el cambio en la política!

Fuente

Curso Básico PHP - Variables

2013-05-01T09:00:00.000-05:00

Variables en PHP

Las variables son “contenedores” de valores. Imagina un recipiente donde podemos poner “algo” para nuestro caso podemos
agregar:

Números enteros

Números reales

Caracteres

Cadenas de caracteres

Objetos

etc

<?php
$x = 5;
$y = 6;
$suma = $x + $y;
?>

Las variables contienen algún valor dado un tipo de dato y este puede cambiar a lo largo de la ejecución del script. Para crear una variable tenemos que seguir algunas reglas como:

Su nombre siempre empieza con el signo de peso ($) seguido por el nombre de la variable
El nombre de la variable siempre debe empezar con una letra o un guión bajo
El nombre de la variable debe de tener solamente números letras y guión bajo (A-z, 0-9, y _ )
El nombre de la variable no debe contener espacios en blanco

Las variables son sensibles a mayúsculas y minúsculas es decir $x y $X, no son lo mismo. Esto aplica para las sentencias de php, por ejemplo For, no es lo mismo que for ó FoR.

Declarar Variables en PHP

Php no tiene un comando para declarar una variable, una variable se crea en el momento en que se le asigna algún valor.

<?php
$hola = "Ola k Ase?";
$numero = 5;
?>

Después de la declaración y asignación de valor a las variables $hola tendrá el valor de “Ola k Ase?” y $numero tendrá asignado el valor 5.

Nota: Para asignar un texto a una variable se usan comillas dobles (“”) y comillas sencillas (‘’).

PHP es un lenguaje de tipado débil es decir en el momento en el que asignas el valor php infiere el tipo de dato y busca el que mejor tipo de dato para manejar ese valor. En un lenguaje de tipado fuerte le tienes que indicar que tipo de dato va a contener la variable antes de asignarlo.

Ámbito de Variables

El ámbito de variable es la parte en el código donde se puede hacer referencia o mandar a llamar, existen varios ámbitos de variable tales como:

local
global
estática
parámetro o argumento

Ámbito local

Una variable declarada dentro de una función es considerada como de ámbito local y sólo puede ser accedida por esta función.

<?php
$texto = “esta es una variable global”;
function mostrarVariableLocal()
{
 echo $texto;
}
mostrarVariableLocal();
?>

Esta función no tiene ninguna salida dado que la variable $texto en su ámbito local no existe.

Nota: Puedes tener variables con el mismo nombre dentro de tus funciones sin afectarlas porque su ámbito de acceso está limitado a la función en la cual fueron declaradas.

Las variables locales son eliminadas tan pronto termina la ejecución de la función.

Ámbito global

Una variable que ha sido declarada fuera de cualquier función tiene un ámbito global, las variables globales pueden ser accedidas desde cualquier parte del script excepto desde funciones. Para acceder a las variables globales desde una función tenemos que usar la palabra reservada global en nuestro código dentro de la función.

<?php
$texto = “esta es una variable global”;
function mostrarVariableGlobal()
{
 global $texto;
 echo $texto;
}
mostrarVariableGlobal();
?>

Php guarda todas las variables globales en un arreglo $GLOBALS[indice], índice es el nombre de la variable que contiene el valor y puede accederse desde cualquier función para obtener o cambiar el valor de la variable global.

<?php
$texto = “esta es una variable global”;
function mostrarVariableGlobal()
{
 echo $GLOBALS[‘texto’];
}
mostrarVariableGlobal();
?>

Ámbito Estático

Cuando se completa una función, todas sus variables se borran habitualmente. Sin embargo, a veces queremos que una variable local no sea eliminada.

Para ello, utilizamos la palabra clave static la primera vez que declaramos la variable.

<?php

function myTest()
{
static $x=0;
echo $x;
$x++;
}

myTest();
myTest();
myTest();

?>

Entonces, cada vez que la función se llama, esa variable seguirá teniendo la información que contenía desde la última vez que la función fue llamada.

Nota: La variable es aún local para la función.

Ámbito de Parámetro o Argumento

Un parámetro es una variable local cuyo valor se pasa a la función por el código de llamada.

Los parámetros se declaran en una lista de argumentos como parte de la declaración de la función:

<?php

function myTest($x)
{
echo $x;
}

myTest(5);

?>

Los parámetros también se denominan argumentos. Vamos a hablar de ello con más detalle en el capítulo de funciones ;)

Curso Básico PHP - Sintaxis Básica [Comentarios]

2013-04-30T20:04:00.000-05:00

Los comentarios son anotaciones que hace el desarrollador para dar una mejor idea sobre lo que realiza su código, como es que funciona y que hacen las variables involucradas y muestra algunos ejemplos ;).

Esto nos es de utilidad para cuando tenemos que realizar mantenimiento de código, si esta bien documentado no tendremos problemas para entender la "Lógica" del que escribió el código.

Php soporta 3 tipos de comentarios 2 estilo C, C++ y uno estilo UNIX Shell.

Comentario en linea //
Multilinea /**/
UNIX Shell #

Veamos algunos ejemplos donde usamos los comentarios en linea:

<?
//comentario de una linea
/*Comentario de 
varias lineas*/
#comentario unix like ;)
?>

Curso Básico PHP - Sintaxis Básica

2013-04-30T16:35:00.000-05:00

Sintaxis Básica PHP

Un segmento de código php puede ser colocado en cualquier lugar del documento. Un fragmento de código siempre (o en la mayoría de
los casos, a menos que tenga activadala directiva short_open_tags=1 en el php.ini,no te alarmes si no entiendes vamos poco a poco) empieza con la etiqueta <?php y termina con la etiqueta ?>:

<?php
//Código acá
?>

La extensión por defecto de un script en php es “.php”, y puede contener o no etiquetas html en el documento, veremos en el ejemplo de abajo la estructura básica para poder crear un hola SQLeros.

<!DOCTYPE html>
<html>
<body>
<h1>Mi página en PHP</h1>
<?php
echo “Hola SQLeros!”;
?>
</body>
</html>

Como pueden apreciar cada línea de código en php debe de terminar con un punto y coma (;) el cual es una separación entre una y otra “instrucción”. Con php tenemos básicamente dos instrucciones para obtener salida de texto al navegador esas “instrucciones” que se llaman funciones(*) son: echo y print.

Sintaxis básica [Comentarios]

Curso Básico PHP - ¿Que es PHP?

2013-04-30T16:02:00.001-05:00

¿Qué es PHP?

PHP Logo

PHP(acrónimo de PHP: Hypertext Preprocessor) es un lenguaje de programación de uso general de código del lado del servidor originalmente diseñado para el desarrollo web de contenido dinámico.

Fue uno de los primeros lenguajes de programación del lado del servidor que se podían incorporar directamente en el documento HTML en lugar de
llamar a un archivo externo que procese los datos.

El código es interpretado por un servidor web con un módulo de procesador de PHP que genera la página Web resultante. PHP ha evolucionado por lo que ahora incluye también una interfaz de línea de comandos que puede ser usada en aplicaciones gráficas independientes.

PHP puede ser usado en la mayoría de los servidores web al igual que en casi todos los sistemas operativos y plataformas sin ningún costo.

PHP fue creado originalmente por Rasmus Lerdorf en 1995. Actualmente el lenguaje sigue siendo desarrollado con nuevas funciones por el grupo PHP. PHP es utilizado en millones de sitios, entre los más destacados se encuentran Wikipedia.org, Facebook.com y Wordpress.com.

Un script de PHP es ejecutado en el servidor de manera secuencial y si tiene que comunicarse con datos los consume, y el "texto" resultante es enviado al navegador/cliente como HTML plano, imagen, archivo de texto, etc.

Sintaxis Básica

Clases Abstractas e Interfaces.

2013-03-10T17:59:00.002-06:00

Hablar de Herencia y Polimorfismo es desgastante, debido a que hay muchas cosas que explicar, así que para darme tiempo de terminar el post "Herencia y Polimorfismo, parte II" hablare acerca de clases abstractas e interfaces, que son parte importante de la Herencia y el Polimorfismo y son más sencillos de explicar.

Clases Abstractas.

Una clase es definida como abstracta cuando uno o más de sus métodos son declarados como abstractos, es decir no tienen ninguna implementación y la primera clase concreta que herede de esta debe implementar todos sus métodos abstractos. Cabe mencionar que una clase abstracta no puede ser instanciada, sino que su propósito es ser extendida, quizás sea difícil imaginar para que puede servir esto, pero intentaremos descubrirlo con un ejemplo.

Pensemos en los celulares, todos los celulares tienen funciones básicas compartidas, como el llamar, contestar, recibir mensajes y enviar mensajes, así que crearemos una clase abstracta con estas funciones.

package AbstractClassAndInterface;

public abstract class Cellphone
{
 private String myNumber;
 
 public Cellphone(String myNumber)
 {
  this.myNumber = myNumber;
 }
 
 public abstract void on();
 
 public abstract void off();
 
 public void call(String number)
 {
  System.out.println("Call to the number " + number);
 }
 
 public void response(String number)
 {
  System.out.println("Response to number " + number);
 }
 
 public abstract void sendMenssage(String message, String number);
 
 public abstract void readMessage(String message);
 
 public String getNumber()
 {
  return this.myNumber;
 }
}

Hemos creado una clase abstracta, que tiene el comportamiento de los celulares estándar todas las clases que hereden de ella, heredaran los métodos call, response y getNumber que ya han sido implementados, y si la clase es concreta deberá implementar los métodos, on, off, sendMessage, readMessage. Podemos notar que la forma en que declaramos la clase Cellphone incluye la palabra abstract que es la que le indica al compilador que la clase es abstracta, al igual los métodos abstractos ocupan la palabra abstract y terminan en punto y coma, sin tener un cuerpo de método.

Si la que extiende la clase abstracta es otra clase abstracta, entonces puede delegar la implementación de los métodos abstractos a la primera clase concreta que herede de ella, y agregar sus propios métodos tanto abstractos como no abstractos.

package AbstractClassAndInterface;

public abstract class Smartphone extends Cellphone
{
 public Smartphone(String number)
 {
  super(number);
 }
 
 public void on()
 {
  System.out.println("Turn on a smartphone");
 }
 
 public void off()
 {
  System.out.println("Turn off a smartphone");
 }
 
 public abstract void surfWeb(String URL);
}

Hemos creado la clase abstracta Smartphone que extiende de la clase abstracta Cellphone, decidimos aquí implementar los métodos on y off, que como se puede observar ahora tienen un cuerpo de método, han eliminado la palabra abstract y el punto coma, además hemos agregado un método abstracto más llamado surfWeb, ahora pasemos a las clases concretas haremos un Android y un Blackberry.

package AbstractClassAndInterface;

public class Android extends Smartphone
{
 public Android(String number)
 {
  super(number);
 }
 
 public void sendMenssage(String message, String number)
 {
  System.out.println("Android Sending a message to number " + number
   + "\r\n" + message);
 }
 
 public void readMessage(String message)
 {
  System.out.println("Android Reading a message: " + message);
 }
 
 public void surfWeb(String URL)
 {
  System.out.println("Android Surfing on the web: " + URL);
 }
}

package AbstractClassAndInterface;

public class Blackberry extends Smartphone
{
 public Blackberry(String number)
 {
  super(number);
 }
 
 public void sendMenssage(String message, String number)
 {
  System.out.println("Blackberry Sending a message to number " + number
   + "\r\n" + message);
 }
 
 public void readMessage(String message)
 {
  System.out.println("Blackberry Reading a message: " + message);
 }
 
 public void surfWeb(String URL)
 {
  System.out.println("Blackberry Surfing on the web: " + URL);
 }
}

Hemos creado nuestros smartphone's, los cuales implementan finalmente todos los métodos abstractos tanto los de la clase abstracta Cellphone como los de Smartphone, es tiempo de probarlo.

package AbstractClassAndInterface;

public class SmartphoneTestDrive
{
 public static void main(String[] args)
 {
  SmartphoneTestDrive test = new SmartphoneTestDrive();
  test.createCellphones();
 }
 
 public void createCellphones()
 {
  Smartphone android = new Android("2291 23 45 67");
  Smartphone blackberry = new Blackberry("2292 34 56 78");
  
  System.out.println("\r\n----Android: " + android.getNumber());
  useCellphone(android);
  
  System.out.println("\r\n----Blackberry: " + blackberry.getNumber());
  useCellphone(blackberry);
 }
 
 private void useCellphone(Smartphone smartphone)
 {
  String cpNumber = "2299 01 23 45";
  String cpNumber2 = "2290 12 34 56";
  
  smartphone.on();
  smartphone.call(cpNumber);
  smartphone.response(cpNumber2);
  smartphone.sendMenssage("Un mensaje de prueba", cpNumber);
  smartphone.readMessage("Te envie un mensaje lo recibiste?");
  smartphone.surfWeb("www.google.com");
 }
}

Funciona, ahora podemos utilizar cualquier smartphone que herede de la clase abstracta, y ejecutarlo con el método useCellphone, si te preguntas por que funciona tendrás que esperar hasta la segunda parte de herencia y polimorfismo, ya que es parte del polimorfismo.

Interfaces.

Una interfaz es básicamente un contrato, la clase que implementa a una interfaz debe de implementar cada uno de los métodos que en ella se definen, una interfaz no contiene variables solo métodos y constantes (al menos en Java), las constantes siempre deben de ser declaradas como "public static final" por el momento no las ocuparemos, vayamos directo al código.

Queremos mandar un mensaje vía Internet de un smartphone a otro, podemos generar una interfaz genérica que envié un mensaje, pero tenemos un problema, Blackberry ocupa BBM(Blackberry Messenger) y Android ocupa WA(Whats App), podríamos crear dos clases abstractas distintas una para Android y otra para Blackberry, pero eso arruinaría nuestro código de prueba anterior, podríamos implementarlo directamente en las clases pero pueden existir tanto Android's como Blackberry's que no soporten esos servicios, es en este momento cuando se vuelve necesario hacer uso de las interfaces.

package AbstractClassAndInterface;

public class Android extends Smartphone implements WhatsApp
{
 public Android(String number)
 {
  super(number);
 }
 
 public void sendMenssage(String message, String number)
 {
  System.out.println("Android Sending a message to number " + number
   + "\r\n" + message);
 }
 
 public void readMessage(String message)
 {
  System.out.println("Android Reading a message: " + message);
 }
 
 public void surfWeb(String URL)
 {
  System.out.println("Android Surfing on the web: " + URL);
 }
 
 public void sendWhatsAppMessage(String message, String user)
 {
  System.out.println("Android Sending WhatsApp message to user " + user
   + "\r\n" + message);
 }
 
 public void receiveWhatsAppMessage(String Message)
 {
  System.out.println("Android Reading WhatsApp message: " + message);
 }
}

package AbstractClassAndInterface;

public class Blackberry extends Smartphone implements  BlackberryMessenger, WhatsApp
{
 public Blackberry(String number)
 {
  super(number);
 }
 
 public void sendMenssage(String message, String number)
 {
  System.out.println("Blackberry Sending a message to number " + number
   + "\r\n" + message);
 }
 
 public void readMessage(String message)
 {
  System.out.println("Blackberry Reading a message: " + message);
 }
 
 public void surfWeb(String URL)
 {
  System.out.println("Blackberry Surfing on the web: " + URL);
 }
 
 public void sendBlackberryMessenger(String message, String user)
 {
  System.out.println("Blackberry Sending BlackberyMessenger to user " + user
   + "\r\n" + message);
 }
 
 public void receiveBlackberryMessenger(String message)
 {
  System.out.println("Blackberry Reading BlackberyMessenger message: " + message);
 }
 
 public void sendWhatsAppMessage(String message, String user)
 {
  System.out.println("Blackberry Sending WhatsApp message to user " + user
   + "\r\n" + message);
 }
 
 public void receiveWhatsAppMessage(String Message)
 {
  System.out.println("Blackberry Reading WhatsApp message: " + message);
 }
}

Hemos creado nuestras interfaces, cabe mencionar que una interfaz puede implementar de otra, es decir podríamos hacer lo siguiente.

public BlackberryMessenger extends WhatsApp

Es decir quién implemente BlackberryMessenger también debería implementar WhatsApp, pero vayamos a la acción modifiquemos Android y Blackberry para enviar mensajes.

Ahora que hemos implementado las interfaces es hora de hacer una prueba, cabe mencionar que por definición todos los métodos en las interfaces son declarados como "public".

package AbstractClassAndInterface;

public class SmartphoneTestDrive
{
 public static void main(String[] args)
 {
  SmartphoneTestDrive test = new SmartphoneTestDrive();
  test.createCellphones();
 }
 
 public void createCellphones()
 {
  Smartphone android = new Android("2291 23 45 67");
  Smartphone blackberry = new Blackberry("2292 34 56 78");
  
  System.out.println("\r\n----Android: " + android.getNumber());
  useCellphone(android);
  
  System.out.println("\r\n----Blackberry: " + blackberry.getNumber());
  useCellphone(blackberry);
 }
 
 private void useCellphone(Smartphone smartphone)
 {
  String cpNumber = "2299 01 23 45";
  String cpNumber2 = "2290 12 34 56";
  
  smartphone.on();
  smartphone.call(cpNumber);
  smartphone.response(cpNumber2);
  smartphone.sendMenssage("Un mensaje de prueba", cpNumber);
  smartphone.readMessage("Te envie un mensaje lo recibiste?");
  smartphone.surfWeb("www.google.com");
  sendWebMessage("Hello im sending a web message", "some user", smartphone);
  receiveMessage("Hi, i received your message, how are you?", smartphone);
 }
 
 private void sendWebMessage(String message, String user, Smartphone smartphone)
 {
  if(smartphone instanceof WhatsApp)
   ((WhatsApp)smartphone).sendWhatsAppMessage(message, user);
  
  if(smartphone instanceof BlackberryMessenger)
   ((BlackberryMessenger)smartphone).sendBlackberryMessenger(message, user);
 }
 
 private void receiveMessage(String message, Smartphone smartphone)
 {
  if(smartphone instanceof WhatsApp)
   ((WhatsApp)smartphone).receiveWhatsAppMessage(message);
  
  if(smartphone instanceof BlackberryMessenger)
   ((BlackberryMessenger)smartphone).receiveBlackberryMessenger(message);
 }
}

Y básicamente es todo, ahora puedes agregar más funcionalidades si así lo deseas.

Happy Coding...

Herencia y Polimorfismo, parte I.

2013-03-03T09:30:00.001-06:00

Me había decidido a escribir sobre patrones de diseño ya que es un tema que actualmente estoy estudiando, sin embargo una de las primeras cosas que aprendí con los patrones de diseño es a favorecer la composición (HAS A) sobre la herencia (IS A), con lo cual quizás si no se conoce lo suficiente se subestime el poder de la herencia, así que lo mejor será comenzar con los principios básicos de programación, aunque por el momento solo tengo planeado abarcar la herencia y el polimorfismo.

Los principios básicos de la programación orientada a objetos son:

· Abstracción

· Encapsulación

· Polimorfismo

· Herencia

Conocer estos principios no te hará un buen programador, pero él no conocerlos bien definitivamente será un obstáculo para seguir avanzando como programador. La abstracción a grandes rasgos te permite ignorar el "cómo funciona" y concentrarte en "que hace", dicho de otra manera no necesitas conocer el funcionamiento de un objeto para hacer uso del mismo, como sucede en algunos casos cotidianos, por ejemplo tu no necesitas saber cómo funciona internamente una computadora para utilizarla, lo mismo sucede con la abstracción no es necesario saber cómo funciona un objeto para hacer uso del mismo.

public class ComputerUser
{
 private Computer computer;
 
 public ComputerUser(Computer computer)
 {
  this.computer = computer;
 }
 
 public Document createDocument(String name)
 {
  return this.computer.createDocument(name);
 }
 
 public void writeDocument(Document doc, String text)
 {
  this.computer.writeDocument(doc, text);
 }
 
 public void closeDocument(Document doc)
 {
  this.computer.Close();
 }
}

En este caso nosotros no conocemos como el objeto "computer" realiza su trabajo sin embargo conocemos sus métodos y los utilizamos, pero no entraré en más detalles.

Encapsulamiento básicamente se refiere al aislamiento de los métodos y propiedades del objeto, a los cuales no tendremos acceso sino solamente mediante métodos específicos definidos por el objeto, retomando el ejemplo anterior podemos tener acceso al objeto "computer" pero no tenemos acceso al atributo "ram", ya que podría ser peligroso que se tenga acceso a la misma, tampoco entraré en más detalles.

La herencia que es nuestro tema principal consiste en la reutilización de código de una clase a otra, es decir una clase que deriva de otra obtiene algunos de los atributos y métodos de la primera, existe la herencia simple y la herencia múltiple, como nos concentraremos en Java solo trataremos la herencia simple.

El Polimorfismo es la habilidad de un método de comportarse de diferentes formas, es una de las características más usadas en la programación orientada a objetos, es el concepto que más se me dificulta explicar así que lo explicare más a detalle en código.

En ocasiones cuando codificamos tenemos una tendencia a repetir código de una clase a otra, lo cual a futuro se vuelve un dolor de cabeza, ya que un cambio a ese código significa modificar más de una clase, aunque esto se puede evitar con un buen diseño orientado a objetos, veamos un ejemplo más práctico, ¡fabriquemos un carro!, fabriquemos el clásico tsuru.

package CarTest;

public class Tsuru
{
 private String model;
 private int year;
 
 public Tsuru()
 {
  this.model = "Tsuru";
  this.year = 2012;
 }
 
 public void turnOn()
 {
  System.out.println("Start the engine");
 }
 
 public void turnOff()
 {
  System.out.println("Stop the engine");
 }
 
 public void accelerate()
 {
  System.out.println("Speed Up");
 }
 
 public void brake()
 {
  System.out.println("Stop the Car");
 }
 
 public void speedChange()
 {
  System.out.println("Change the velocity with Clutch");
 }
 
 public String getModel()
 {
  return this.model;
 }
 
 public int getYear()
 {
  return this.year;
 }
 
 public String toString()
 {
  return "I'm a " + this.model + " of " + this.year;
 }
}

Perfecto tenemos nuestro tsuru, este puede acelerar, frenar y cambiar de velocidad, tiene todo lo necesario para dar una vuelta, lo cual es tentador pero primero fabriquemos otro carro, esta vez un chevy... Un momento prácticamente tendremos que repetir todo el código de tsuru a chevy ya que son capaces de realizar las mismas acciones, repetir el código suena a una tarea tediosa y aburrida, así que lo mejor será buscar otras alternativas es momento de hacer uso de la herencia.

Por cierto si te preguntas por la palabra "this" está es utilizada para hacer referencia a la instancia actual, e igual lo tratare en otro post.

Creamos una clase abstracta que contenga los métodos que comparten "turnOn", "turnOff", "accelerate", "brake", "speedChange", "getModel", "getYear", "toString", un momento... nuestro carro puede ser automático o estándar, eso significa que nuestro método "speedChange" va a variar dependiendo del tipo carro, podemos dejarlo así y confiar en que el programador que ocupe esta clase abstracta se acuerde de modificar el método en un carro automático, eso no suena muy bien, lo mejor será obligar al programador a escribir su propia implementación haciendo al método abstracto, eso suena mucho mejor, así no tendremos que preocuparnos por un carro automático intentando cambiar de velocidad con un Clutch inexistente.

package CarTest;

public abstract class Car
{
 private String model;
 private int year;
 
 public Car(String model, int year)
 {
  this.model = model;
  this.year = year;
 }
 
 public void turnOn()
 {
  System.out.println("Start the engine");
 }
 
 public void turnOff()
 {
  System.out.println("Stop the engine");
 }
 
 public void accelerate()
 {
  System.out.println("Speed Up");
 }
 
 public void brake()
 {
  System.out.println("Stop the Car");
 }
 
 public abstract void speedChange();
 
 public String getModel()
 {
  return this.model;
 }
 
 public int getYear()
 {
  return this.year;
 }
 
 public String toString()
 {
  return "I'm a " + this.model + " of " + this.year;
 }
}

Quizás te preguntarás porque en el constructor de la clase abstracta "Car" recibe de parámetros el Modelo y el año, esto es porque en Herencia los atributos y métodos que se heredan son los marcados con el "scope" public, protected y default, los públicos pueden ser heredados por cualquier otra clase dentro o fuera del "package", los default solo por clases dentro del "package" y los protected por clases dentro del "package" y por clases fuera del "package" pero solo a la primer subclase, hablaré de esto en otra ocasión. Así que no podemos modificar los atributos modelo y año directamente ya que son privados, así que delegamos esa responsabilidad al constructor que si puede modificar estos atributos.

Ahora modifiquemos nuestra clase Tsuru para que herede de Car, y creemos nuestra clase Chevy.

package CarTest;

public class Tsuru extends Car
{
 public Tsuru()
 {
  super("Tsuru", 2012);
 }
 
 public void speedChange()
 {
  System.out.println("Change the velocity with Clutch");
 }
}

package CarTest;

public class Chevy extends Car
{
 public Chevy()
 {
  super("Chevy", 2008);
 }
 
 public void speedChange()
 {
  System.out.println("Automatic change of velocity");
 }
}

Al llamar al método "super" lo que hacemos es llamar al constructor de la clase base, es decir el constructor de la clase que heredamos, en este caso la clase Car, y le pasamos los argumentos modelo y año.

Perfecto nuestras clases ahora son bastante compactas y tienen todas las funcionalidades de un carro, por el momento dejaremos el tema hasta aquí, pero seguiremos con él en la segunda parte de este post, ya que no hemos terminado con la herencia, no hemos visto polimorfismo, y además tenemos que probarar nuestro carros.

Happy Coding...

¿Es legal usar SQL server express en entornos de producción?

2013-02-25T16:15:00.001-06:00

mucha gente tiende a pensar que la versión xpress es sólo para desarrollo pero en realidad puedes usarla en cualquier entorno siempre y cuanto no tengas problemas de tamaño, con SQL server xpress 2012 estás limitado a:

1 Cpu (cuatro cores)
1 GB de memoria ram
10 GB de espacio por cada base de datos

No importa si tu servidor tiene más recursos, simplemente SQL server sólo usará esos como máximo.

Así mismo tampoco hay ningún problema en usar integration services o reporting services con la versión express (unicamente en que ese caso necesitamos la versión express with advanced services)

Eso si, hay que tener en cuenta que con la versión xpress tenemos las herramientas para ejecutar reportes y paquetes ssis de integration pero no las herramientas para crearlos ni para automatizarlos

Es decir: si, es completamente legal usar SQL server versión express en entornos de producción

Para más información sobre licencias podéis consultar en:

http://www.microsoft.com/en-us/sqlserver/get-sql-server/how-to-buy.aspx

Y para descargar la versión express podéis descargarla aquí:

http://www.microsoft.com/en-us/download/details.aspx?id=29062

Saludos!

Visto | Devjoker

Enumerados en Java

2013-02-10T16:55:00.000-06:00

Una de las características que personalmente me agradan más en Java que en C# son los enumerados, los enumerados son una lista de ítems que son establecidos en algún momento en el código y después de haberse declarado son constantes.

Supongamos que tenemos una pizzería donde tenemos diferentes especialidades y tamaños, para ejemplificar nos enfocaremos en el tamaño de la pizza, se ofrecen 3 tamaños de pizza en la pizzería que son: personal, mediana, grande. Ahora crearemos la clase encargada de esta tarea.

package EnumTest;

public class PizzaEnum
{
 private String size;
 
 public PizzaEnum(String size)
 {
  this.size = size;
 }
 
 public String getSize()
 {
  return this.size;
 }
}

Y la clase encargada de ordenar una pizza

package EnumTest;

public class OrderPizza
{
 public static void main(String[] args)
 {
  PizzaEnum pizza = new PizzaEnum("Large");
  System.out.println("The pizza size is " + pizza.getSize());
 }
}

Este código funciona para nuestros propósitos, alguien ordena una pizza Grande, así que se crea el objeto pizza con el parámetro "Large" y obtenemos la pizza del tamaño que se ordeno. Sin embargo el código es propenso a errores debido a que nunca es validado el parámetro de entrada, con lo que se podría pedir una pizza de tamaño miniatura sin que esta existiera en nuestro menú.

En este caso podemos recurrir a los enumerados, establecer un número determinado de ítems (tamaños) y solo permitir la utilización de esos ítems en la creación de los objetos (pizzas). Cambiaremos la clase PizzaEnum para funcionar con un enumerado.

package EnumTest;

public class PizzaEnum
{
 private PizzaSize size;
 
 public PizzaEnum(PizzaSize size)
 {
  this.size = size;
 }
 
 public PizzaSize getSize()
 {
  return this.size;
 }
}

enum PizzaSize
{
 Personal,
 Medium,
 Large
}

Ahora al momento de ordenar una pizza, solo podemos utilizar los 3 tamaños de pizza declarados en nuestro enumerado, así evitaremos que se intente ordenar algún otro que no exista en el menú.

Hemos resuelto de forma elegante el problema, pero ahora tenemos otra dificultad se ordenan las pizzas de tamaños existentes pero cuando se cortan nunca se hacen con el mismo número de rebanadas, probablemente podríamos resolverlo con otro enumerado y una serie de validaciones extras para vincular el tamaño de la pizza con el número de rebanadas en que se corta, pero Java permite hacerlo de una forma más interesante.

Pensemos en el enumerado como si fuera una clase, entonces tenemos un constructor, atributos y métodos, pues es de esta manera como lo maneja Java, esto nos permite resolver el problema de una forma sencilla, en el constructor pasaremos como parámetro el número de rebanadas y expondremos este atributo para obtenerlo cuando sea necesario.

package EnumTest;

public class PizzaEnum
{
 private PizzaSize size;
 
 public PizzaEnum(PizzaSize size)
 {
  this.size = size;
 }
 
 public PizzaSize getSize()
 {
  return this.size;
 }
}

enum PizzaSize
{
 Personal(4), Medium(8), Large(16);
 
 PizzaSize(int slices)
 {
  this.slices = slices;
 }
 
 private int slices;
 public int getSlices()
 {
  return this.slices;
 }
}

El enumerado ha cambiado ahora además de los tres tamaños de pizza declarados anteriormente, hemos agregado dos paréntesis y un numero, un constructor con un parámetro de entrada, una variable "slices" de tipo entero y un método "getSlices". Ahora ordenemos una pizza mediana.

package EnumTest;

public class OrderPizza
{
 public static void main(String[] args)
 {
  PizzaEnum pizza = new PizzaEnum(PizzaSize.Medium);
  System.out.println("The pizza size is " + pizza.getSize());
  System.out.println("The number of slices cut is " + pizza.getSize().getSlices());
 }
}

Como es que funciona, bueno primero que nada creamos una Pizza de tamaño mediano, es decir creamos un PizzaEnum con el parámetro de entrada PizzaSize.Medium, lo que sucede internamente al hacer esto es que se ejecuta el constructor del enumerado con el parámetro de entrada de PizzaSize.Medium es decir "8", y este asigna el valor pasado a la variable slices, ahora cuando se obtenga el numero de rebanadas siempre será el mismo para cada tamaño de pizza.

Ahora solo falta seguir jugando con los enumerados, por ejemplo intenta agregar siempre el mismo número de sobres de cátsup por cada pizza ordenada.

Happy Coding :D

Instalar cinnamon en OpenSUSE 12.2

2013-02-08T23:43:00.003-06:00

Cinnamon el shell de Gnome 3 desarrollado por Linux Mint que ofrece una experiencia de usuario tradicional similar a Gnome 2 con panel inferior, menú principal, indicador de espacio de trabajo etc..cada vez

está más presente de forma oficial, en un mayor número de distribuciones linux, entre ellas openSUSE.

La versión actualmente disponible de Cinnamon es los repositorios de openSUSE es la 1.5.7 (gestor de ventanas muffin 1.0.9), y se espera que pronto llegue la 1.6.0. Ha habido algunos cambios en los repositorios oficiales tal como anunciaba Nelson Marquesen las listas de correo de openSUSE (se recomienda a los que tengan el repo antiguo que cambien al nuevo), así que ahora para instalar Cinnamon desde linea de comandos añadiríamos el repo

zypper ar http://download.opensuse.org/repositories/X11:/Cinnamon:/GNOME34/12.2/X11:Cinnamon:GNOME34.repo

y después lo instalamos con

zypper in cinnamon

A mi particularmente no me atrae demasiado Cinnamon (en general todo lo que me recuerda al querido gnome 2 ahora lo ya lo percibo como anticuado), y en el equipo que lo instalé iba bastante más lento que con gnome-shell o kde, por lo que me duró apenas 5 minutos, pero supongo que habrá muchos que les interese esta alternativa más clásica.

Tips SQLeros: KeyCodes en JavaScript

2013-02-07T16:15:00.001-06:00

Aquí muestro una tabla con los códigos que tienen cada tecla del teclado cuando la pulsamos. Esto nos sirve cuando queremos programar una función en nuestra página que responde a una determinada tecla para realizar una determinada acción:

Los los KeyCodes de los eventos de Windows.

Keyboard key Pressed	IE JavaScript Key Code value	Firefox JavaScript Key Code value
backspace	8	8
tab	9	9
enter	13	13
shift	16	16
ctrl	17	17
alt	18	18
pause/break	19	19
caps lock	20	20
escape	27	27
page up	33	33
Space	32	32
page down	34	34
end	35	35
home	36	36
arrow left	37	37
arrow up	38	38
arrow right	39	39
arrow down	40	40
print screen	44	44
insert	45	45
delete	46	46
0	48	48
1	49	49
2	50	50
3	51	51
4	52	52
5	53	53
6	54	54
7	55	55
8	56	56
9	57	57
a	65	65
b	66	66
c	67	67
d	68	68
e	69	69
f	70	70
g	71	71
h	72	72
i	73	73
j	74	74
k	75	75
l	76	76
m	77	77
n	78	78
o	79	79
p	80	80
q	81	81
r	82	82
s	83	83
t	84	84
u	85	85
v	86	86
w	87	87
x	88	88
y	89	89
z	90	90
left window key	91	91
right window key	92	92
select key	93	93
numpad 0	96	96
numpad 1	97	97
numpad 2	98	98
numpad 3	99	99
numpad 4	100	100
numpad 5	101	101
numpad 6	102	102
numpad 7	103	103
numpad 8	104	104
numpad 9	105	105
multiply	106	106
add	107	107
subtract	109	109
decimal point	110	110
divide	111	111
f1	112	112
f2	113	113
f3	114	114
f4	115	115
f5	116	116
f6	117	117
f7	118	118
f8	119	119
f9	120	120
f10	121	121
f11	122	122
f12	123	123
num lock	144	144
scroll lock	145	145
My Computer (multimedia keyboard)	182	182
My Calculator (multimedia keyboard)	183	183
semi-colon	186	186
equal sign	187	107
comma	188	188
dash	189	189
period	190	190
forward slash	191	191
open bracket	219	219
back slash	220	220
close bracket	221	221
single quote	222	222

Espero les sirva!

[SOLUCIÓN] "No se ha podido cargar el complemento" (Flash Chrome 24.x) en Linux

2013-02-02T01:37:00.000-06:00

Hace rato vi la imagen que está como cabecera de este post en un grupo de facebook que sigo. La imagen la posteó un amigo explicando su problema con Flash Player y Fedora 16 después de una update reciente. Es curioso porque justo había notado el mismo problema (en Fedora 18) antes de checar su post pero no le presté atención y simplemente me cambié de navegador hasta que leí el post de mi amigo. Ahí les va la solución:

NOTA: Me comentan que pasa lo mismo en Ubuntu 12.10, probablemente estemos ante un problema que afecta a todas las distros.

Para solucionar esto, necesitamos tener Flash Player instalado. ¿Cómo saber si lo tengo instalado? Si tu firefox reproduce videos flash pero chrome no, entonces lo tienes instalado. Nos vamos a: chrome://plugins/dentro de chrome y desactivamos flash pepper como se muestra a continuación:

Una vez inhabilitado, reiniciamos Chrome y listo! ya nos funcionará el plugin de Flash Player sin problema alguno en nuestro Chrome 24.x dentro de nuestro sistema Linux.

visto acá

Aumentar/Disminuir Brillo de Pantalla Gateway NV59C en OpenSUSE

2013-01-29T00:38:00.000-06:00

Buenas SLQeros, el día de hoy les traigo un comando que esta bastante bueno para manipular el brillo de la lap. En mi caso una Gateway NV59C, Porque tenia un problema con los botones de brillo ya que aunque subiera o bajara el brillo no había cambio aparente.

Bueno para poner el brillo deseado en el portátil tiene que escribir el comando.

xrandr --output LVDS1 --brightness 0.85

Donde LVDS1 es el identificador de la pantalla activa y el numero decimal es el brillo a asignar a la pantalla. Pulsan Enter y listo.

Saludos y espero que les sirva!

Saber que números tienen whatsapp

2013-01-02T01:49:00.004-06:00

Buenas noches SQLeros espero este año nuevo tengan la dicha de realizar todas sus metas y hacer lo que les guste.

El día de hoy les comparto rápidamente un script en Python para saber los números que tienen whatsapp en su localidad.

El código es el siguiente:

Python 2.x

import urllib
import urllib2
import random
import time
url = "https://sro.whatsapp.net/client/iphone/iq.php"
post_data_dictionary = {"cd":"1", "cc":"52","me":"","u":""}
for x in range(2291010000,2291010500):
    post_data_dictionary["me"] = x
    print "Consultando Numero: %s" % (x)
    #sets the user agent header
    http_headers = {"User-Agent":"Mozilla/4.0 (compatible; MSIE 5.5;Windows NT)"}

    post_data_encoded = urllib.urlencode(post_data_dictionary)
    request_object = urllib2.Request(url, post_data_encoded, http_headers)

    response = urllib2.urlopen(request_object)
    html_string = response.read()
    if(html_string.find("<dict>")>0):
        print "%s Tiene WhatsApp" % (x)
        try:
            # This will create a new file or **overwrite an existing file**.
            f = open("whatsappNumbers.txt", "w")
            try:
                f.write("%s\n" % (x)) # Write a string to a file
            finally:
                f.close()
        except IOError:
            pass
    await = random.randrange(1,5)
    print "await %s seconds..." % (await)
    time.sleep(await)

Para Python 3.x

import urllib.request, urllib.parse, urllib.error
import urllib.request, urllib.error, urllib.parse
import random
import time
url = "https://sro.whatsapp.net/client/iphone/iq.php"
post_data_dictionary = {"cd":"1", "cc":"52","me":"","u":""}
for x in range(2351000239,2351010001):
    post_data_dictionary["me"] = x
    print("Consultando Numero: %s" % (x))
    #sets the user agent header
    http_headers = {"User-Agent":"Mozilla/4.0 (compatible; MSIE 5.5;Windows NT)"}

    post_data_encoded = urllib.parse.urlencode(post_data_dictionary)
    binary_data = post_data_encoded.encode("utf-8") 
    request_object = urllib.request.Request(url, binary_data, http_headers)

    response = urllib.request.urlopen(request_object)    
    html_string = response.read()
    if(html_string.decode().find("<dict>")>0):
        print("%s Tiene WhatsApp" % (x))
        try:
            # This will create a new file or **overwrite an existing file**.
            f = open("whatsappNumbers.txt", "a")
            try:
                f.write("%s\n" % (x)) # Write a string to a file
            finally:
                f.close()
        except IOError:
            pass
    #await = random.randrange(1,5)
    #print("await %s seconds..." % (await))
    #time.sleep(await)

¡Listo! Ya es cosa de que se pongan a jugar con los números y ver combinaciones... Como tip a los 5000 números el server de WA te bloquea... :3

¡Saludos y Feliz año 2013!

La pila, el montículo y las variables de referencia (The stack, the heap and the reference variables)

2012-12-30T12:22:00.000-06:00

A pesar de tener años programando este era uno de los temas que no lograba comprender al cien por ciento, después de investigar un poco entendí que lo desconocía incluso más de lo que pensaba, ya que aunque realmente sea un tema muy "simple" y pareciera al principio no muy crítico (debido quizás al Garbage Collector), resulta necesario conocerlo para comprender como se comporta nuestro programa en memoria, y para conocer cómo resolver conscientemente esos frustrantes errores de "StackOverFlowException" y "HeapOverFlowException" (java.lang.OutOfMemoryError en este caso), cabe mencionar que los temas abarcados aquí están enfocados a Java, aunque también pueden aplicar a otros lenguajes.

La pila y el montículo (The Stack and the Heap)

Primero que nada debemos conocer que existen dos espacios en donde se ejecutan nuestras aplicaciones, uno de ellos es la pila (Stack), en ella se guardan las variables locales y los métodos en ejecución, el otro es el montículo (Heap), en el se guardan las variables de instancia y los objetos. Cada Hilo (Thread) de la aplicación tiene su propia pila (Stack) pero todos comparten el mismo montículo (Heap), las variables y métodos de la pila (Stack) son eliminados al terminar su ejecución, las variables y objetos del montículo (Heap) son eliminados al no tener ninguna referencia hacia ellos y a capricho del Garbage Collector (al menos en Java y C#, aquí los gurús de C aplican el clásico "Ha Ha" con voz del Nelson), primero nos enfocaremos en la pila (Stack).

La pila (Stack)

Quizás una de las preguntas existenciales más difíciles es ¿De cuánto espacio dispone la pila (Stack)?, y la respuesta es un rotundo depende, incluso entre las mismas versiones de JVM (Java Virtual Machine) en distintas maquinas depende, y su explicación y configuración da para otra publicación más (insertar link cuando se tenga) por lo cual no trataremos aquí a fondo ese tema y solo te diremos que depende de la JVM, el sistema operativo, la configuración y el hardware, la siguiente pregunta a resolver sería ¿Cómo funciona la pila?, lo cual explicaremos a grandes rasgos, pero primero necesitamos un pequeño código para la explicación.

public class Program
{
                static int sumNNumbers(int n)
                {
                               if (n == 1)
                               {
                                               return 1;
                               }
                               else
                               {
                                               return n + sumNNumbers(n - 1);
                               }
                }

                public static void main(String[] args)
                {
                               System.out.println("Sum of the first 5 numbers: " + sumNNumbers(5));
                }
}

La pila (Stack) funciona como su homónima estructura de datos pila, el último elemento en llegar es el primero en salir (Last In First Out, LIFO), su comportamiento es parecido a una pila de objetos, por ejemplo una pila de platos si queremos añadir un nuevo plato a la pila lo ponemos en la cima, cuando queremos retirar un plato tomamos también el de encima.

Lo mismo sucede en la pila (Stack), y en cada llamada se almacena lo siguiente:

· La dirección a la que se debe retornar después de la llamada.

· Los datos pasados como parámetros de la llamada.

· Las variables locales utilizadas por la función llamada.

· Los datos devueltos, si la función los devuelve.

Si ejecutamos el código arriba expuesto, a grandes rasgos la pila se comportaría de esta manera:

· El método main es puesto en la pila (Stack), con la variable args como parámetro.

· El método println es puesto en la pila (Stack), con la dirección a la cual debe retornar después de su llamada y con su parámetro que es un String.

· El método sumNNumbers es puesto en la pila (Stack), con la dirección a la cual debe retornar y con un entero como parámetro.

· El método sumNNumbers es llamado recursivamente, puesto en la pila (Stack) n veces, con todos sus datos (dirección retorno, parámetros).

· Una vez que llega a su último llamado, este es puesto en la pila (Stack), con la dirección a la cual debe retornar, un entero como parámetro, y al terminar su ejecución su valor de retorno, después regresa a su línea de retorno, devuelve el resultado y finalmente elimina sus variables y parámetros de la pila (Stack).

· Se insertan uno por uno los valores de retorno del método sumNNumbers, y también se eliminan uno por uno sus datos de la pila (Stack) según se entreguen resultados.

· Se retorna a la función println imprime el resultado en pantalla, una vez terminada su ejecución elimina sus datos de la pila (Stack) y regresa el método main.

· El método main termina su ejecución y elimina sus datos del Stack.

Internamente su comportamiento es más complejo pero para fines didácticos nos basta, la tercera pregunta sería ¿Por qué se genera un StackOverFlowException? Esto es debido a que el espacio de la pila (Stack) es limitado, y cuando algún método quiere insertar sus datos en la pila (Stack) y no se tiene espacio suficiente se genera esta excepción. Un ejemplo sería un método que se llama recursivamente de manera infinita ó en C# una propiedad que se auto asigne.

El montículo (Heap)

Otra pregunta difícil es ¿De cuánto espacio dispone el montículo (Heap)? Al igual que la pila (Stack) depende de la JVM, el sistema operativo, la configuración y el hardware, y ¿Cómo funciona el montículo (Heap)? Es un espacio donde se guardan variables de instancia y objetos (recuerda que es Java), que en lenguajes como Java y C# no pueden ser eliminados directamente sino con el Garbage Collector, y en lenguajes como C deben ser eliminados explícitamente (free), en este caso nos enfocaremos en Java y un poco en el Garbage Collector.

Después de este mini examen (espero haber aprobado) vamos directo al tema que es responder completamente la última pregunta. Los datos guardados en el montículo (Heap) son las variables de instancia y los objetos, pero ¿Qué es una variable de instancia? Son simplemente las propiedades expuestas de los objetos (instancias), para ejemplificarlo crearemos una clase llamada Car

class Stereo
{
                public void turnOn()
                {
                               System.out.println("Really cool music!!!");
                }
}

public class Car
{
                String carModel; // Instance Variable
                int carYear; // Instance Variable
                Stereo carStereo; // Instance Variable

                public static void main(String[] args)
                {
                               Car car;
                               car = new Car();
                               car.carModel = "Sentra";
                               car.carYear = 2005;
                               car.carStereo = new Stereo();
                               car.turnOnStereo();
                }

                void turnOnStereo()
                {
                               this.carStereo.turnOn();
                }
}

En este ejemplo las variables de instancia son carModel, carYear y carStereo, quizás en estos momentos piensas ¡¡Oye carStereo es un objeto también!! Pero carStereo no es un objeto sino una variable de referencia, ¿Qué es una variable de referencia?... Se explicara más adelante.

Volviendo al montículo (Heap), los objetos también son guardados en el mismo, en el código de Car hemos creado dos objetos, un objeto Car y un objeto Stereo y la instrucción que reservo la memoria, creo los objetos y regreso las referencias de los objetos es new, y ¿Cómo eliminamos los objetos? Eliminando todas las referencias hacia ese objeto, es decir eliminando las variables de referencia ó apuntando estas a otros objetos, aunque esto no los elimina los hace elegibles por el Garbage Collector quien finalmente es el encargado de eliminarlos.

Por último ¿Por qué se genera un java.lang. OutOfMemoryError? Al igual que la pila (Stack) el montículo (Heap) también es limitado, el JVM se asegura a través del Garbage Collector de tener la mayor cantidad de memoria disponible, cuando el Garbage Collector no puede recuperar suficiente memoria para la creación de un nuevo objeto se generá este error.

Variables de Referencia (Reference Variables)

Las variables de referencia, son tipos de datos especiales que guardan la referencia al objeto, el tipo de objeto y datos acerca de como acceder a los atributos y métodos del mismo, aunque es muy común en Java decir que los objetos se pasan por referencia en realidad no es exactamente así, lo que realmente sucede es que se hace una copia de una variable de referencia a otra, es decir se copian los bits de una variable a otra y como ambas hacen referencia al mismo objeto pareciera que se ha pasado el objeto por referencia, el código de abajo ejemplifica esta situación.

public class Cat
{
                String catName;

                public static void main(String[] args)
                {
                               Cat cat = new Cat();
                               cat.Name = "Meow";
                               System.out.println(cat.Name); // Imprime Meow
                               setCatName(cat);
                               System.out.println(cat.Name); // Imprime Meow
                }

                static void setCatName(Cat cat)
                {
                               cat = new Cat();
                               cat.Name = "Presley";
                               System.out.println(cat.Name); // Imprime Presley
                }
}

En el método main se crea un objeto Cat que es referenciado a través de la variable de referencia cat, y se le asigna el nombre "Meow" y se imprime, después se pasa como parámetro esta variable de referencia para el método estático setCatName, dentro de este se crea un nuevo objeto y se asigna a la variable de referencia que había sido pasada como parámetro, se le da el nombre "Presley" y se imprime, al regresar al método principal y volver a imprimir se muestra la cadena Meow, ¿Por qué no se imprimió Presley?, esto es debido a que al utilizar la instrucción new se creó un nuevo objeto y se referencio en la variable de referencia pasada como parámetro, a partir de ese momento las dos variables dejaron de referenciar al mismo objeto por lo que los cambios realizados en SetCatName no afectaron a la objeto original cat.

Grabar escritorio del pc desde la consola con ffmpeg

2012-12-09T03:46:00.001-06:00

Como su nombre lo dice el día de hoy les mostraré como grabar la pantalla con la consola con un script usando la biblioteca ffmpeg, es muy sencillo solo tenemos que ejecutar en la consola. Para openSUSE.

zypper install ffmpeg

Después de instalarse tenemos lo que necesitamos para poder grabar nuestra pantalla desde la consola. ;)

Tenemos que ejecutar el siguiente comando:

ffmpeg -f alsa -ac 2 -i hw:0,0 -f x11grab -s $(xwininfo -root | grep 'geometry' | awk '{print $2;}') -r 10 -i :0.0 -sameq -f mp4 -y output.mp4

Bueno cuando terminen sólo detienen el script y listo, acá les dejo un videotutorial que hice

Saludos y espero que les sirva!

Reiniciar Campo Identity en SQL Server

2012-12-08T22:31:00.003-06:00

Bueno espero les sirva este post, ya que yo cada vez que necesito hacerlo lo tengo que buscar para saber como se hace.

Los valores identity aumentan de forma secuencial, si eliminamos los registros de una tabla, el valor Identity no se inicializa, sino que continua con su último valor.

Para poder reiniciar el campo se ejecuta la siguiente instrucción:

`1`	`DBCC CHECKIDENT (<nombre_tabla>, RESEED,<valor_inicial>)`

Eso es todo, Saludos.

vía: Blog de Paxxxword

Agregar programas al inicio de sesión en GNOME3

2012-12-05T03:26:00.001-06:00

Buenas SQLeros, el día de hoy comparto con ustedes un tip que me gusto mucho y me fue de gran ayuda a la hora de usar Dropbox en openSUSE 12.2, dado que el proceso lo tienes que ejecutar cada vez que necesitas que se sincronicen las carpetas en tu PC.

El proceso es sencillo necesitamos agregar el comando de dropboxd de la carpeta .dropbox-dist

Pulsamos alt + F2 para ejecutar el comando gnome-session-properties

Ya con el cuadro de dialogo abierto daremos clic en Añadir

Nos saldra un cuadro de dialogo como este y vamos a llenarlo como corresponde en el campo Nombre podremos Dropbox para mi caso. Puede ser el nombre que más les guste. En el campo comando pondremos /home/USAURIO/.dropbox-dist/dropboxd y en Comentario pondremos un comentario que haga referencia a nuestro comando.

Ahora cerraremos la sesión e iniciaremos de nuevo para ver los cambios y si se ha ejecutado el comando personalizado en este caso Dropbox.

Espero les sea de utilidad, ¡hasta la próxima!

Instalar Monodevelop 3.0.5 en OpenSUSE 12.2

2012-12-02T00:21:00.001-06:00

Buenas noches SQLeros el día de hoy vamos a instalar MonoDevelop desde el código fuente porque para esta fecha no se encuentra un paquete precompilado para OpenSUSE 12.2, aparte de eso la versión que esta para los repositorios de OpenSUSE es la 2.8.x y esa tiene un bug cuando seleccionas una solución te manda una excepción.

Nos dirigimos a la dirección http://monodevelop.com/download y seleccionamos la opción Source Code. Para este caso la url es la siguiente lo descargamos con:

wget http://download.mono-project.com/sources/monodevelop/monodevelop-3.0.5.tar.bz2

Después lo descomprimimos para poderlo instalar, usando:

tar -xvf monodevelop-3.0.5.tar.bz2

Ingresamos en el directorio monodevelop3.0.5 con:

cd monodevelop3.0.5

Ahora vamos a configurar el paquete, usando:

./configure --prefix=`pkg-config --variable=prefix mono`

Ahora terminando la ejecución del comando usamos:

make
make install

Esperamos y ¡listo!

Acá les dejo una captura de pantall del MonitoDevelop