jueves, 31 de diciembre de 2015

Scala ... en ejemplos sencillos no. 7 [Mapas]

Los mapas o "hashmap" en lenguajes como Scala, Java, etc. son colecciones de objetos desordenados. Se compone de una "llave o identificador" y su correspondiente valor.

Mapa mapa = Mapa ()
Objeto obj= Objeto()
Integer valor= Integer()
mapa.put(obj,valor)

Podemos obtener algo como esto:
mapa: {"uno":1,"dos":2,"tres":3}
mapa:{"A":3223,"Z":4329,"W":4322,"ACF":434}

En Scala podemos crear un mapa escribiendo:
var mapa: Map[String,Int] = Map()

Un mapa vacío que puede ser llenado de la siguiente manera:
mapa += (objLlave -> valor)

Tenemos así:  Mapas.scala
object Mapas{
   def main(args: Array[String]): Unit ={
       var mapa: Map[String,Int] = Map()
       mapa += ("uno" -> 1)
       mapa += ("tres" -> 3)
       mapa += ("Clave" -> 456)
   }
}

Para recorrer el mapa creado:
mapa.keys.foreach{ k =>
     Console.println("Llave:"+k)
     Console.println("Valor:"+mapa(k))
}


sábado, 12 de diciembre de 2015

Groovy en ejemplos no.9: Leer un JSON

Usar archivos JSON para el intercambio de información entre aplicaciones se ha vuelto muy indispensable. Es una alternativa para sustituir el uso de archivos XML.

Un archivo JSON se compone de:
  • Una colección tipo diccionario con nombre y valor.
  • Un arreglo o lista ordenada.
Ejemplo. Un archivo JSON llamado "persona.json" puede tener una estructura similar a la siguiente:
{
   "persona": {
          "nombre": "Mariana",
           "edad": 32
   }
}

Donde "persona" es el nodo (objeto) principal. Los valores pueden ser de tipo boolean (true o false), númericos y cadenas.  También podemos definir arreglos (que inician y cierran con corchetes) como este:
{
   "persona": {
          "nombre": "Mariana",
           "edad": 32,
          "libros":[
           "El extraño caso de el perro en el ropero",
           "El error de llamarse Godofredo"
         ]
   }
}

Donde "libros" es el arreglo.

¿Cómo leer el archivo JSON?
  • Necesitamos crear un archivo json (que cumpla con la estructura adecuada), y que denominaremos como "persona.json"
  • Usar la librería groovy.json.JsonSlurper

leerJSON.groovy

import groovy.json.JsonSlurper
import java.io.File

static main(args) {
  def json=new JsonSlurper()
  def archivo=new File("persona.json")

  if(archivo.exists()){
    println "Archivo existe:${archivo.getAbsolutePath()}"
    def objeto=json.parse(archivo) 
    if(objeto !=null){
        if(objeto.persona.nombre == null && objeto.persona.nombre == null){
            println "Objetos nulos"
        }
        javax.swing.JOptionPane.showMessageDialog(null, "Nombre:"+objeto.persona.nombre+"\nEdad:"+objeto.persona.edad)
    }
  }

}


Para acceder a una propiedad del objeto es necesario definir su nombre, por ejemplo, si queremos obtener el "valor" de la propiedad "nombre" debemos acceder de este modo:  objeto.persona.nombre

Ejecutamos: groovy leerJSON.groovy

Y obtenemos:




Links
https://geekytheory.com/json-i-que-es-y-para-que-sirve-json/
http://www.json.org/json-es.html

sábado, 28 de noviembre de 2015

Javascript en ejemplos ... uso de document.getElementById().style

En esta ocasión crearemos un ejemplo para editar el estilo de un componente html.

Supongamos que tengo dos div de la siguiente manera:
<div id="miIdentificador1">
       <p>Este es el primer div</p>
</div>

<div id="miIdentificador2">
       <p>Este es el segundo div</p>
</div>


Ahora creo un archivo javascript y escribo una función:
function cambiaEstilo(){
      /* código */
}

Para acceder al componente div opto por crear un document y usar la función getElementById(), esta función nos permite acceder mediante su "identificador":

function cambiaEstilo(){
   document.getElementByd("miIdentificador1")
   document.getElementByd("miIdentificador2")
}

Ahora puedo usar la propiedad style para editar el estilo:

document.getElementById("miIdentificador1").style.backgroundColor="#ACD";document.getElementById("miIdentificador1"').style.color="#FF0040";document.getElementById("miIdentificador1").style.marginTop=".98in";
document.getElementById("miIdentificador1").style.fontFamily = "Impact"; document.getElementById("miIdentificador1").style.textAlign = "center";
document.getElementById("miIdentificador1").style.textIndent = "50px";

Para activar este script se puede usar un componente <button>

<button id="miBoton2" onclick="cambiaEstilo()">Cambiar estilo</button>




lunes, 16 de noviembre de 2015

HTML5 en ejemplos no.1


En un post anterior había escrito sobre HTML5, la estructura básica de un documento y algunas características. Además de algunos sitios de interés.

Este lenguaje de hipertexto (en su quinta versión) nos permite incluir etiquetas para incrustar imágenes "dinámicas", manipulación de audio y vídeo, entre otras cosas más.  Se considera el asesino de Flash (Adobe Flash), pues pretende que el desarrollador abandone esa tecnología.

Antes del auge de las apps, tablets, iphone, android, etc. Los programadores y diseñadores nos emocionaba(o aterraba) aprender a crear animaciones usando Flash (en ese entonces propiedad de Macromedia), el manejo de líneas de tiempo, fotogramas, efectos, etc. La llegada de HTML5 prácticamente acabo con la necesidad de usar esta tecnología. Depender de la instalación de plugins para reproducir archivos .swf era bastante tedioso para los usuarios (además de que algunos sitios se volvían muy "pesados" en cargar).

¿Qué encontraremos en HTML5?
La capacidad de crear y manipular gráficos, mejor manejo a formularios, mejorar el intercambio de información entre aplicaciones web (ej. metadatos), y conocer la ubicación del usuario. Entre otras cosas más.


1. En este ejemplo haremos uso de la API de Geolocalización

Creamos un archivo js llamado geolocalizar.js, escribimos:

/*las opciones*/
  var options = {
        enableHighAccuracy: true,
        timeout: 5000,
        maximumAge: 0
    };

/*método para mostrar errores*/
    function error(err) {
        console.warn('ERROR(' + err.code + '): ' + err.message);
    };


/*método que define la latitud y longitud del origen*/
    function origen(position){
        var latitud = position.coords.latitude;
        var longitud = position.coords.longitude;

    }
/*método para activar la golocalización

 recibe parámetros de opción,error y la posición del origen 
*/
    function activa_origen(){
        navigator.geolocation.getCurrentPosition(origen,error,options);
    }

 
Tenemos ahora una página con formato HTML5 , la llamaremos localiza.html:

<!DOCTYPE html>
 <html lang="es">
 <head>
  <meta charset="utf-8">
  <title>Mi primer página HTML5</title>

<script src="geolocalizar.js"></script>
</head>
<body>
<header><h1>Geolocalización</h1></header>
<section id="contenedor">
<article>
CodemonkeyJunior
</article>
<aside>


<!-- Aqui esta el botón que ejecuta el script -->
<button onclick="javascript:activa_origen();">Mostrar Posici&oacute;n</button>

 </aside>
<article></article>
</section>
<footer>@codemonkeyjunior</footer>
</body>
</hml>


Links
https://whatwg.org/
http://www.w3schools.com/
https://es.wikipedia.org/wiki/HTML5


sábado, 26 de septiembre de 2015

Groovy en ejemplos no. 8 ... convirtiendo un archivo groovy a javascript

En el post anterior vimos un ejemplo usando Grooscript, ahora veremos como convertir un archivo *.groovy a *.js.  Escribiremos tres archivos:
  • Philosopher.groovy
  • conversor.groovy
  • Philosopher.js
En el primero tendremos la clase Philosopher. El segundo servirápara convertir ese código a javascript. El tercero es donde se contendré el código javascript generado.


Philosopher.groovy
class Philosopher{
    String nombre
    int edad
}



conversor.groovy
@Grab('org.grooscript:grooscript:1.2.1')

import org.grooscript.GrooScript

GrooScript.convert('Philosopher.groovy', 'Philosopher.js')



Ejecutamos: groovy conversor.groovy

Philosopher.js
function Philosopher() {
  var gSobject = gs.inherit(gs.baseClass,'Philosopher');
  gSobject.clazz = { name: 'Philosopher', simpleName: 'Philosopher'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.nombre = null;
  gSobject.edad = null;
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
 
  return gSobject;
};


Es solo una forma de como convertir código groovy a javascript.

domingo, 20 de septiembre de 2015

Groovy en ejemplos no. 7 ... usando Grooscript


En esta ocasión usaremos Grooscript. Se trata de una herramienta para convertir código escrito en Groovy a Javascript.

GroovyToJavascript.groovy
//es necesario importar la librería grooscript.1.2.1
@Grab('org.grooscript:grooscript:1.2.1')

import org.grooscript.GrooScript


class Philosopher{
    String nombre
    int edad
}

def resultado = GrooScript.convert '''
    def kant = new Philosopher(nombre:"Immanuel Kant")
    kant.with{
        edad= 36
    }
'''

println resultado


Compilamos:
groovyc GroovyToJavascript.groovy

Ejecutamos:
groovy GroovyToJavascript.groovy

Nos imprimirá:
var kant = Philosopher(gs.map().add("nombre","Immanuel Kant"));
kant.withz(function(it) {
  return gs.sp(this, 'edad',36);
});


Podemos guardar el la salida en un archivo javascript:
groovy GroovyToJavascript.groovy > groovy.js


Para el siguiente post veremos más a fondo esta herramienta.



LiveScript: Creando una clase


Recordemos que Javascript es un lenguaje interpretado, permite la programación funcional y la orientada a objetos. Muchas veces, debido a su nombre,es confundido por Java.  Es un lenguaje de script para aplicaciones web.

El estándar Javascript
Algunos consideran que el estándar de Javascript ha fracasado y por esa razón ha proliferado una gama de nuevos lenguajes de programación como  TypeScript, CoffeeScript,LiveScript, etc. Puede ser verdad, estos nuevos lenguajes ofrecen escribir código más sencillo de leer y mantener que escribir líneas y líneas de código que muchas veces no todos entendemos.

En esta ocasión veremos un ejemplo de como crear una clase usando LiveScript y compararemos el código resultante en Javascript.

Tenemos el código LiveScript:

clase.ls
#creando clase en LiveScript
class Codemonkey
     numero= 0
     real= 0.0
     cadena= ''

#instanciando la clase
code = new Codemonkey
code.numero= 45
code.real= 9.009
code.cadena= 'Creando una clase'

Compilamos:
lsc -c clase.ls

Nos generará un código en Javascript:
Codemonkey.js
// Generated by LiveScript 1.3.1
(function(){
  var Codemonkey, code;
  Codemonkey = (function(){
    Codemonkey.displayName = 'Codemonkey';
    var numero, cadena, real, prototype = Codemonkey.prototype, constructor = Codemonkey;
    numero = 0;
    cadena = '';
    real = 0.0;
    function Codemonkey(){}
    return Codemonkey;
  }());
  code = new Codemonkey;
  code.numero(45);
  code.real(9.009);
  code.cadena('Creando una clase');
}).call(this);


Podemos observar que el código resultante es más complejo que el escrito en LiveScript. Aunque eso solo es una ventaja.


sábado, 19 de septiembre de 2015

LiveScript


LiveScript es un lenguaje de programación que compila a Javascript. Es muy parecido a otro lenguaje llamado CoffeScript. En este post veremos un ejemplo usando este lenguaje.

¿Cómo se instala LiveScript?
Instalar node.js 
sudo apt-get update
sudo apt-get install nodejs
sudo apt-get install npm
Instalar Livescript
 sudo npm install -g LiveScript

En la terminal de comandos teclear:
lsc --version

Hola.ls

cad= 'Programando en LiveScript'
alert cad


Compilamos: lsc -c Hola.ls

Nos genera un archivo JS con el siguiente código:
// Generated by LiveScript 1.3.1
(function(){
  var cad;
  cad = 'Programando en LiveScript';
  alert(cad);
}).call(this);



Pegamos el código JS generado (Hola.js) en una sencilla página html.

<script src="Hola.js" type="text/javascript">  </script >

Mostrara una ventana alert.



Links
http://livescript.net/
http://coffeescript.org/

sábado, 18 de julio de 2015

Una pregunta ... ¿Por qué quieres ser programador?

"Algunos comienzan una cosa sin tener la más remota idea de como comenzar y lo peor aún ... como terminar"
 :: El Libro de los naufragios::

Hace algunos años les preguntaron a James Gosling y Linus Torvalds (por mencionar algunos) donde habían aprendido a programar y si realmente la educación universitaria fue la diferencia que marco el destino de sus carreras. Sus respuestas fueron: "No aprendí a programar en la escuela, sino por mi cuenta leyendo libros y practicando" y "al principio aprendí por mi cuenta. Conseguí mi primer trabajo como programador antes de ir a la universidad". Otros más dijeron que: "Las universidades me enseñaron muchas cosas útiles, incluso la mayoría de las bases que sería mi trabajo futuro".  Para estas "celebridades" de la informática el gusto y una buena educación académica fue esencial para ser programador. Pero ¿qué es un programador?  y más aun ¿existe la carrera de programador o desarrollador?.


  El programador (de una manera burda) es  quien, sin importar si tiene o no una carrera universitaria( la que sea) o hasta estudios básicos, escribe, documenta (en algunos casos) y depura los programas que la computadora ejecutará y obtendrá información útil para ser usada para cualquier propósito. Ahora bien esta cabe señalar que "esta carrera" no existe como tal. Un programador puede ser cualquier persona: un contador, un abogado, un médico, y ¡hasta un niño!. No, no se trata de una broma. Es la realidad.  Esta claro que por lo general los programadores vienen de carreras como Sistemas computacionales, Informática administrativa, Ingeniería en computación, etc. , pero ya no es raro encontrar gente que trabaja "haciendo programas" y no ha estudiado ninguna de esas carreras.  ¿La calidad de su trabajo tiene que ver con lo estudiado en la universidad?, ¿será que se equivocaron al elegir una profesión? ... algunas preguntas incomodas.

   Y si de preguntas incomodas hablamos ... se les podría hacer la siguiente: ¿por qué quieres ser programador?. Habría respuestas como:
  • Me gusta la computación y la tecnología
  • Se gana muy bien como programador
  • No lo sé, creo me gustan los retos
  • etc.
Yo creo que tiene que ver más por el gusto aunque la necesidad también puede ser.

Links
https://blog.udemy.com/es/cinco-preguntas-de-perl-para-una-entrevista-que-cada-programador-debria-saber/


domingo, 31 de mayo de 2015

Programando en C# no. 5 ... System.Windows.Forms en Mono

En este post tan solo veremos como crear una ventanita usando System.Windows.Forms desde una aplicación C# (usando el compilador mono).

¿Por qué mono?
Porque me parece adecuado para quienes quieren aprender .Net sin necesidad de instalar Windows. 

¿Por qué no usar Wine para instalar Visual Studio .Net?
Porque siempre hay algún error al instalar dependencias en Linux, al menos así los he tenido. Creo que la mejor opción es siempre usar  Visual Studio desde Windows.

Hola.cs
using System;
using System.Windows.Forms;

public class Hola{
    public static void Main(string[] args){
       
        try{
           MessageBox.Show("Hola, estoy usando windows forms desde Linux");
        }
        catch(Exception ex){
            Console.Error.WriteLine("Error: ["+ex.Message+"]");
            Environment.Exit(0);
        }
    }
}


Compilar: mcs Hola.cs -r:System.Drawing.dll -r:System.Windows.Forms.dll

Ejecutar: mono Hola.exe

Salida:

sábado, 23 de mayo de 2015

¿Por qué Perl?


   Tal vez a muchos no les llame la atención el lenguaje de programación Perl, tal vez ni sepan que existe, o que ventajas o desventajas tiene con respecto a lenguajes como Java o Python. Sin embargo, considero que no se pierde el tiempo en conocerlo.

   Cuando recién iniciaba la carrera, los profesores recomendaban usar lenguajes como C para aprender los conceptos básicos de la programación. Conforme pasaba el tiempo hablaban de lenguajes o entornos de programación como Visual Basic o Delphi (Pascal) y según ellos eran los ideales para conseguir un trabajo. Después con el boom de las aplicaciones web, PHP se convirtió en el lenguaje más popular.

 

  Lenguajes como Java y C# comenzaban a tener más adeptos, así como entornos de desarrollo o IDES como Visual Studio, Eclipse y NetBeans. Nadie hablaba de lenguajes como Perl o LISP. Eso era del conocimiento de los más nerds de los nerds.

   La primera vez que escuche sobre Perl fue en un foro sobre trucos de programación (no recuerdo el nombre) y servidores,se recomendaba el uso de ese lenguaje si querías ser administrador de sistemas y base de datos (si de esos gorditos bonachones que saben un buen de cosas y que te dan un buen de soluciones a tus dudas de programación y de sistemas). Había interesantes scripts para la administración de servidores, detección de intrusos en red, y hasta para la recuperación de datos. Eso sí algunos scripts eran bastante complejos de entender.

   Pero a todo esto ¿por qué  Perl? ... con este lenguaje se puede hacer todo, desde las clásicas aplicaciones tipo consola hasta aplicaciones web. Incluso aplicaciones con interfaz gráfica. Es relativamente fácil de aprender si tienes familiaridad con lenguajes como C o PHP (de hecho este último se inspiro en el).

   No es la octava maravilla del mundo, tienes sus ventajas y desventajas como cualquier otro.

Links
http://trabajodeprogramacionperl.blogspot.mx/p/que-es-y-para-que-sirve.html

domingo, 17 de mayo de 2015

Programando en C# no. 4

En esta ocasión crearemos un programa que nos permita conectarnos a una base de datos MySQL desde C# (usando Mono).

Necesitamos lo siguiente:
  • Usar la base de datos "test" de MySQL
  • Crear una tabla llamada "persona"
  • Descargar la librería MySql para .Net

Tabla persona:
create table persona(id int auto_increment,nombre varchar(45),apellidoP varchar(45));

insert into persona(nombre,apellidoP) values ("Armando","Cadena"), ("Juan","Villa"), ("Maria","Estevez");

Una vez descargada la librería la instalamos (desde la terminal Linux):
sudo gacutil -i MySql.Data.dll

ConexionBD.cs

using System;
using System.Data;
using MySql.Data.MySqlClient;

public class ConexionBD{
    public static void Main(string[] args){
        string connectionString =
          "Server=localhost;" +
          "Database=test;" +
          "User ID=root;" +
          "Password=5432;" +
          "Pooling=false";
       IDbConnection dbcon;
       dbcon = new MySqlConnection(connectionString);
       dbcon.Open();
       IDbCommand dbcmd = dbcon.CreateCommand();
       string sql =
           "SELECT nombre, apellidoP " +
           "FROM persona"
;
       dbcmd.CommandText = sql;
       IDataReader reader = dbcmd.ExecuteReader();
       while(reader.Read()) {
            string FirstName = (string) reader["nombre"];
            string LastName = (string) reader["apellidoP"];
            Console.WriteLine("Nombre: " +
                  FirstName + " " + LastName);
       }

       reader.Close();
       reader = null;
       dbcmd.Dispose();
       dbcmd = null;
       dbcon.Close();
       dbcon = null;
    }
}



Compilación:
mcs Monaso.cs -r:System.Data.dll -r:/home/Codemonkey/Documentos/librerias/mysql-connector-net-6.9.6-noinstall/v4.0/MySql.Data.dll

Ejecución:
mono Monaso.exe

Links
http://www.monodevelop.com/documentation/

martes, 5 de mayo de 2015

Julia en ejemplos no. 3: Creando "clases"

Retomando los ejemplos de código en Julia en esta ocasión conoceremos como crear estructuras Type. Semejantes  a las clases de lenguajes como C, Python y Java.

 ¿Cómo creo una "clase"?
Con la siguiente sintaxis:

type Nombre_Tipo
  ...
  ...
end

Ejemplo. Crear una "clase" en Julia introduciendo valores  y mostrarlas en pantalla.

Definiremos entonces:
  • Una estructura Type con el nombre de "Objeto"
  • Un método llamado "propiedades"
  • Un método para mostrar las "propiedades"
  • Una función externa que nos permita introducir datos
 #la "clase" Objeto
type Objeto
    propiedades::Function
 

#constructor
    function Objeto()
        this = new()
 #método para imprimir valores
        function ObtenerDatos(altura::Int64,ancho::Int64,grosor::Int64)
            println("Objeto{alto:",altura,"ancho:",ancho,"grosor:",grosor,"}")
        end

        this.propiedades = ObtenerDatos

        return this
    end
end


#función externa para introducir datos
function entrada(prompt::String="")
   print(prompt)
   chomp(readline())
end

#bloque principal del programa
begin
    objeto = Objeto()#instancia
    altura = int(entrada("Introduce altura:"))
    ancho = int(entrada("Introduce ancho:"))
    grosor = int(entrada("Introduce grosor:"))
    objeto.propiedades(altura,ancho,grosor)
end


Ejecución del código: julia Clase.jl


Links
http://chrisvoncsefalvay.com/2015/02/14/types-and-inheritance.html
https://thenewphalls.wordpress.com/2014/02/19/understanding-object-oriented-programming-in-julia-part-1/

martes, 31 de marzo de 2015

Ceylon: Interoperabilidad con Java ... javax.swing

Continuamos los ejemplos del uso de librerías Java en código Ceylon. En el post anterior vimos como importar las librerías básicas de Java, ahora importaremos el paquete javax.swing.

Tendremos tres archivos:
  1. module.ceylon
  2. package.ceylon
  3. run.ceylon
En este archivo importamos el módulo que incluye a la librería javax.swing

module.ceylon
module holaCeylon "1.0.0"{
    import java.base "7";
    import java.desktop "7";//incluye a javax.swing
}


Este archivo indicamos el paquete principal (holaCeylon) de nuestro programa.
package.ceylon
shared package holaCeylon;

El archivo que se compilará y ejecutará. Se trata de un mensaje que nos muestra la versión del lenguaje en una ventanita tipo alert.


run.ceylon
import javax.swing { JOptionPane }

shared void run(){
    JOptionPane.showMessageDialog(null,"Hola desde Ceylon ``language.version`` ");
}



Compilamos y ejecutamos:

También podemos hacer uso de showInputDialog() para introducir datos:
import javax.swing { JOptionPane }

shared void run(){
    value nombre=JOptionPane.showInputDialog("Introduce tu nombre");
    JOptionPane.showMessageDialog(null,"Hola ``nombre``");   
}


Convertir esos datos en Float o Integer. Podemos hacer un simple menú con tres opciones: calcular grados celsius, grados fahrenheit y salir.

import javax.swing { JOptionPane }

shared void run(){
    value c=Calculo();
    String? opc=JOptionPane.showInputDialog("\t1. Calcular grados Fahrenheit\n2. Calcular grados Celsius\nSalir (cualquier tecla)");

    if(exists opc){
        value opc_=opc;
        switch (opc)
        case ("1") {
            Float? numero=parseFloat(JOptionPane.showInputDialog("Introduce grado Celsius"));
            if(exists numero){
                value numero_=numero;
                JOptionPane.showMessageDialog(null,"Celsius: ``c.fahrenheit(numero)``");   
            }

        }
        case ("2") {
            Float? numero=parseFloat(JOptionPane.showInputDialog("Introduce grado Fahrenheit"));
            if(exists numero){
                value numero_=numero;
                JOptionPane.showMessageDialog(null,"Celsius: ``c.celsius(numero)``");   
            }
        }
        else {
            process.exit(0);
        }

    }
}

class Calculo(){
    shared Float celsius(Float fahr){
        return (fahr - 32) / 1.8;
    }

    shared Float fahrenheit(Float cels){
        return (1.8 * cels) + 32;
    }
}

Al compilar y ejecutar obtendremos lo siguiente:






Listo.
Links
http://ceylon-lang.org/documentation/1.1/reference/interoperability/java-from-ceylon/


lunes, 30 de marzo de 2015

Ceylon: Interoperabilidad con Java

Ceylon nos permite la interoperabilidad con Java, podemos importar sus librerías e integrarlas a nuestro código.  En este post haremos un ejemplo de como importar librerías de Java a nuestro código Ceylon.

En este caso no usaremos ningún IDE, usaremos la consola de comandos (en mi caso uso Linux). Crearemos una estructura de directorios similar a esta:
 /home/codeMonkey/Documentos/source/holaCeylon/

Tendremos estos tres archivos con la extensión *.ceylon:
  1. run.ceylon
  2. module.ceylon
  3. package.ceylon
Dentro de cada archivo escribiremos:

run.ceylon
shared void run(){
   print("Importando librerias de Java en Ceylon");
}

module.ceylon
module holaCeylon "1.0.0"{
    import java.base "7"; // se debe tener instalada la versión 7 del JDK
}


package.ceylon
shared package holaCeylon;

Ahora volvemos al archivo run.ceylon e importamos la librería java.util.HashMap de Java.

run.ceylon
import  java.util  { HashMap }

shared void run(){
   print("Importando librerias de Java en Ceylon"); 
   value romanos = HashMap<String,Integer>();
    romanos.put("I", 1);
    romanos.put("V", 5);
    romanos.put("X", 10);
    romanos.put("L", 50);
    romanos.put("C", 100);
    romanos.put("D", 500);
    romanos.put("M", 1000);
    print(romanos.values());

}

Compilamos:
ceylon compile source/holaCeylon/run.ceylon

Cuando compilamos se crea un directorio más o menos así:




Ejecutamos: ceylon run holaCeylon/1.0.0


¡Listo!. Espero sirva de algo para quienes les interesa este lenguaje.

domingo, 29 de marzo de 2015

Aserciones

¿Qué es una Aserción?
Es una sentencia que puede ser falsa o verdadera, nos sirve para verificar o comprobar el funcionamiento de nuestro código. Básicamente es lo que supone el programador debe ocurrir en alguna parte del programa.


Un ejemplo en Java:
 int cantidad=this.getTotal();
if(cantidad < 0){
    out.out.println("la cantidad es de:"+cantidad);
}
else{
    out.println("la cantidad es de:"+cantidad);
    assert cantidad == 0 :"Parece que la cantidad no es 0";
}


En este fragmento de código vemos como usar las aserciones, en este caso usamos la palabra assert e indicamos una condición a cumplir. Las aserciones no son exclusivas de Java, también podemos encontrarlas en lenguajes como: Ceylon, Python, C++, entre otros más.

En Java 
Compilamos: javac -g Asercion.java
Ejecutamos:  java -ea Asercion

Asercion.java
import static java.lang.System.out;

public class Codemonkey{
    public static void main(String[] args) {
    ControlUsuarios cu=new ControlUsuarios();
    cu.setTotal(1);
    cu.mostrar();
    }
}

class ControlUsuarios{
    private int total=0;

    public ControlUsuarios(){

    }

    public void setTotal(int total){
        this.total=total;
    }

    public int getTotal(){
        return total;
    }

    public void mostrar(){
        int cantidad=this.getTotal();
        if(cantidad < 0){
            out.println("la cantidad es de:"+cantidad);
        }
        else{
            out.println("la cantidad es de:"+cantidad);
            assert cantidad == 0 :"Parece que la cantidad no es 0";
        }
    }

}


En Ceylon
Compilamos: ceylon compile source/Asercion.ceylon
Ejecutamos: ceylon run default

Asercion.ceylon
shared void run(){
  value cu=ControlUsuarios();
  cu.total=0;
  cu.mostrar();
}

class ControlUsuarios(){
  shared variable Integer total=0;

  shared Integer getTotal(){
    return total;
  }

  shared void mostrar(){
    Integer cantidad=this.getTotal();
    if(cantidad < 0){
      print("la cantidad es: ``cantidad``");
    }else{
      print("la cantidad es: ``cantidad``");
      assert(cantidad == 0);//Parece que la cantidad no es 0
    }
  }
}


En C++

Compilamos: g++ -o asercion  asercion.cpp
Ejecutamos: ./asercion

asercion.cpp
#include "iostream"
#include <cassert>

using namespace std;

class ControlUsuarios{
    private:
        int total;

    public:
     ControlUsuarios(){}
     virtual ~ControlUsuarios(){}
     void setTotal(int total){
         this->total=total;
     }
     int getTotal(){
         return total;
     }
     void mostrar(){
         int cantidad=this->getTotal();
         if(cantidad < 0){
            cout<<"la cantidad es de:"<<cantidad<<endl;
        }
        else{
            cout<<"la cantidad es de:"<<cantidad<<endl;
            assert(cantidad == 0); //"Parece que la cantidad no es 0";
            assert(("Parece que la cantidad no es 0",cantidad == 0));
        }
    }

};


int main(int argc, char** argv){
    ControlUsuarios cu = ControlUsuarios();
    cu.setTotal(1);
    cu.mostrar();
    return 0;
}



En Python

Ejecutamos: python Asercion.py

Asercion.py
class ControlUsuarios(object):
  total=0
  def mostrar(self):
    cantidad=self.total
    if cantidad < 0:
      print "cantidad es:",cantidad
    else:
      print "cantidad es:",cantidad
      assert cantidad == 0 #Parece que no es 0

cu=ControlUsuarios()
cu.total=1
cu.mostrar()



La verificación de programas (algoritmos) es un tema bastante extenso y complejo, este post solo trata del uso de las aserciones de manera muy superficial.

Links
http://es.axiacore.com/blog/2008/05/ejemplo-aserciones-assert-java/
http://www.lab.dit.upm.es/~lprg/material/apuntes/assert/aserciones.htm 
http://pablasso.com/200812/que-es-una-asercion/

viernes, 27 de febrero de 2015

Probar Java 8 en línea

En el post anterior se hablo sobre algunos sitios que nos permiten programar en .Net sin necesidad de instalación. Ahora le toca el turno a Java, en este caso la versión no. 8.

Se trata del sitio http://www.tryjava8.com/ el cual tiene una interfaz sencilla y fácil de usar.

Una forma para aprender Java 8 y sus nuevas características.

Código usado de
http://www.tutorialspoint.com/java/java8_lambda_expressions.htm

domingo, 22 de febrero de 2015

Programar en C# sin necesidad de instalación

En esta ocasión hablaremos de tres sitios que nos permiten programar aplicaciones en C# sin necesidad de instalarlo en nuestras máquinas:

  1. .Net Fiddle >> https://dotnetfiddle.net/
  2. Try JSIL >> http://jsil.org/try/ 
  3. C# Pad >> http://csharppad.com/
.Net Fiddle
Nos permite escribir el código, generar nuevos archivos, compartirlo y ejecutarlo. Muy completo.


Try JSIL
 Se trata de un sitio que nos permite crear aplicaciones gráficas usando el lenguaje C# usando el compilador Mono (una alternativa a .Net). Contiene varios ejemplos para probar.
 
C#Pad
Por último tenemos a CSharp Pad, intuitivo,sencillo  y  bastante fácil de entender

Ya no hay excusa para no querer aprender a usar este lenguaje.

domingo, 15 de febrero de 2015

Python: jugando con PyZenity (3era parte)

En esta ocasión seguimos usando la librería PyZenity. Ahora crearemos un sencillo menú con tres opciones:
  1. Información del sistema
  2. Espacio en los discos duros
  3. Ver directorio
Importaremos estas librerías:
  • os
  • platform
  • commands
  • PyZenity
Nos servirán para ejecutar comandos, obtener plataforma que se ocupa (en este caso se usa Linux), almacenar el resultado de comandos y para los componentes gráficos respectivamente.

Como va ser un script para sistemas Linux hacemos una función que identifique si se trata de un sistema con plataforma Linux:

def identifica():
  return platform.system() == 'Linux'


Para ejecutar un comando (sin necesidad de almacenar el resultado) usamos este método:

os.system('clear')#este comando limpia la pantalla

Ahora si queremos guardar el resultado de un comando usaremos esto:
status, output = commands.getstatusoutput("ls -l")

Para introducir datos de entrada:
entrada=GetText(contenido)

Para mostrar resultados:
InfoMessage('Mensaje')

El código completo:
import os,platform,commands
from PyZenity import *

def identifica():
  return platform.system() == 'Linux'

def menu():
  contenido="\tMenu\n1. Opcion 1[Informacion del sistema]\n2. Opcion 2[Espacio en los discos duros]\n3. Opcion 3[Ver el directorio]\nElije tu opcion (q para salir):"
  while True:
    entrada=GetText(contenido)
    try:
      numero=int(entrada)
      if numero == 1:
        status, output = commands.getstatusoutput("uname -a")
        InfoMessage(str(output))
      elif numero == 2:
        status, output = commands.getstatusoutput("df")
        InfoMessage(str(output))
      elif numero == 3:
        status, output = commands.getstatusoutput("ls -l")
        InfoMessage(str(output))
      else:
        ErrorMessage('Opcion incorrecta.\nIntenta de nuevo')
    except:
      if entrada == 'q':
        break
      Warning('Por favor solo numeros')


def main():
  if identifica():
    os.system('clear')
    try:
      menu()
    except ImportError:
      print "Debes tener instalada la libreria PyZenity"

  else:
    print "Este script solo funciona en plataformas Linux"

if __name__ == '__main__':
  main()