viernes, 11 de julio de 2014

Nuevos lenguajes de programación: Nimrod, Dylan, y Julia


Julia
Parecido a R, es un lenguaje enfocado al cálculo, estadística y la matemática en general.

http://julialang.org/

Nimrod
Un lenguaje que a primera vista nos recuerda a Scala o Python. Y no, no tiene nada que ver con Nimrod de los X Men.

https://github.com/Araq/Nimrod/wiki
http://steved-imaginaryreal.blogspot.mx/2013/09/nimrod-return-of-pascal.html
http://stackoverflow.com/questions/tagged/nimrod
http://nimrod-lang.org/download.html


Dylan
Una mezcla entre Ruby y Python, al menos a mi parecer.Y si, el nombre esta basado en Bob Dylan.

http://opendylan.org/books/dpg/
https://github.com/dylan-lang

viernes, 4 de julio de 2014

Una herramienta para aprender a programar: PSeInt

PSeInt
Se trata de una herramienta enfocada a la enseñanza y aprendizaje de programación, se emplea un lenguaje algorítmico muy sencillo de utilizar.  Lo puedes instalar en Linux, Windows, y Mac.

 Al inicio te pedirá que lenguaje algorítmico usarás (te muestra una lista). A mi parecer es bastante sencillo e intuitivo.  Ideal para quienes están o quieren aprender a programar.

Link
http://pseint.sourceforge.net/slide/pseint.html
http://pseint.sourceforge.net/

domingo, 8 de junio de 2014

Programando en Ruby ... no. 5

Clases en Ruby
Es muy fácil crearlas en este lenguaje.



Al igual que en Python y/o Groovy no es necesario crear métodos getter y setter para acceder a las propiedades de la clase.

En Python sería algo así:
class Diamante(object):
     def __init__(self, valor):
          self.valor=valor

#main
diamante=Diamante('20.9')
print "valor :%f\n"%(diamante.valor)

En Groovy así:
class Diamante{
     Float valor
}
#main
static main(args){
  def diamante=new Diamante(valor:20.9f)
  println "valor $diamante.valor"
}

¿Existe la herencia en Ruby?
Si, existe la herencia en este lenguaje. La sintaxis es:

class ClasePadre
...
end

class ClaseHija  < ClasePadre
...

end


Ejemplo. Creamos una clase padre  llamada 'Animal' y dos clases hijas 'Spider' y 'Bird'

#clase padre
class Animal 
      attr_accessor :no_patas
       def initialize(no_patas)
           @no_patas=no_patas
            puts "objeto animal creado"
      end
end

#clase hija
class Spider  < Animal
      attr_accessor :especie
       def initialize(no_patas, especie)
           super(no_patas)
           @especie=especie
            puts "objeto spider creado"
      end
end

#clase hija

class Bird   <  Animal
      attr_accessor :color
       def initialize(no_patas, color)
            super(no_patas)
           @color=color
            puts "objeto bird creado"
      end
end


Además de heredar la propiedad 'no_patas' de la clase padre 'Animal' las clases hijas pueden poseer otras más. Para terminar creamos el 'main' del programa.

begin
  spider=Spider.new(8,'negra')

  bird=Bird.new(2,'amarilla')

   puts "Spider"
   puts "no. de patas:"+spider.no_patas.to_s
   puts "color: #{spider.color}"

   puts "Bird:"
   puts "no. de patas:"+bird.no_patas.to_s
   puts "color: #{bird.color}"

rescue Exception => e
  puts e.message
end


Ejecutamos:  ruby animales.rb


Links
http://codemonkeyjunior.blogspot.mx/2014/03/programando-en-ruby-no-4.html
http://codemonkeyjunior.blogspot.mx/2014/02/programando-en-ruby-no-3.html
http://codemonkeyjunior.blogspot.mx/2014/01/programando-en-ruby-no-2.html
http://codemonkeyjunior.blogspot.mx/2013/06/programando-en-ruby-no-1.html
http://codemonkeyjunior.blogspot.mx/2013/05/un-vistazo-ruby.html

sábado, 7 de junio de 2014

Javascript ... aspectos básicos

¿Qué puedo hacer con Javascript?
Existen bastantes librerías y Frameworks para desarrollo de aplicaciones de todo tipo, depende de la necesidad y trabajo del desarrollador sacarle el mejor provecho.

Hace años parecía imposible usarlo para aplicaciones que no fueran web.

¡Hola, mundo!
Para crear un archivo Javascript es necesario guardarlo con la extensión *.js, para invocarlo dentro de una archivo *.html es necesario agregar las etiquetas <script  src="miArchivo.js">  </script>.

miArchivo.js
function  inicio(){
   alert('¡Hola, mundo!')
}

miPagina.html
<! -- código javascript -->
<script src="miArchivo.js">  </script>

<body onload="inicio()">
<h1>Iniciando en Javascript</h1>
</body>

También se puede agregar el código dentro de la página *.html.
<script>
function inicio(){
  alert('¡Hola, mundo!')
}
</script>

<body onload="inicio()">

</body>

Al abrir este archivo en nuestro navegador nos muestra una ventana con el mensaje:!Hola, mundo¡

¿Como se declaran las variables?
Con la palabra var, puedes asignarles cualquier valor.

var entero=20
var cadena='Los presidentes se reunieron para hablar sobre las reformas ...'
var lista=[new Date(), 'T', 120,'tres', [2,4,5,6]]

Sentencias de control
Existen tres sentencias de control para mantener el flujo del programa,muy similar a C.

  • Secuencial
  • Iterativa: for, while
  • Selectiva: switch, if-else


Ejemplo. Declaramos un arreglo con un tamaño de 3 y lo recorremos con un for y un while.
var arreglo=new Array(3);
arreglo[0]=12;
arreglo[1]=32;
arreglo[2]=46;

//con for
for(var i=0;i<arreglo.length;i++){
   document.writeln(arreglo[i]);
}

//con while
var cont=0;
while(cont<arreglo.length){
        document.writeln('[arreglo[cont]);
        cont++;
}

Funciones
Podemos crear funciones usando la siguiente sintaxis:

function nombreFuncion(param1, param2, ...){
     //cuerpo
   [return]  variable
}

Ejemplo. Creamos una función que suma dos valores.

function sumar(a,b){
    return a+b
}

No es indispensable que las funciones devuelvan valor alguno.

Objetos en Javascript
Podemos crear objetos de la siguiente manera:

function Torre(tamanyo,color){
   this.tamanyo=tamanyo;
   this.color=color;
}

Nombre: Torre
Propiedades: tamanyo, y color


Usando la propiedad 'prototype' podemos agregar propiedades al objeto Torre:
  
//obtenemos la información
Torre.prototype.getInfo=function(){
    return 'color: '+this.color+' , tamaño:' +this.tamanyo;
};

//los getters y setters al estilo Java
Torre.prototype.getTamanyo=function(){
   return this.tamanyo;
};
    
Torre.prototype.setTamanyo=function(tam){
  this.tamanyo=tam;
};

Torre.prototype.setColor=function(col){
  this.color=col;    
};

Torre.prototype.getColor=function(){
  return this.color;
};

Formularios
Podemos acceder a los valores de los formularios html mediante javascript.

Ejemplo. Creamos un formulario con una caja de texto y un botón, obtendremos el valor de la caja de texto y lo mostraremos en una ventana.


<!-- código javascript -->
function obtiene(){
//accedemos al valor mediante un id, en este caso es 'dato'
    var dato=document.getElementById('dato');

//mostramos el valor obtenido y su tipo
    alert('El dato introducido es: '+dato.value+' , es de tipo: '+typeof(dato));

//borramos el contenido de la caja de texto
    document.getElementById('dato').value='';
}

<!-- código html -->
<form>
<input type="text" id="dato" value=""/>
    <button onclick="obtiene()">Obtener dato</button>
</form>

Introducimos texto  y presionamos el botón que lo envía a la función obtiene().

Javascript es un lenguaje muy usado hoy en día, existen bastantes frameworks que proveen  muchas utilidades para las aplicaciones. 

viernes, 30 de mayo de 2014

IDEs para programar en C# ... no Visual Studio .NET

Lista de IDEs para programar en C#

XDevelop
http://freecode.com/projects/xdevelop
Un IDE para programar en C# y Java. Al parecer esta descontinuado.

QuickSharp
http://quicksharp.sourceforge.net/
Un IDE para programar aplicaciones Microsoft .Net (C#). No tan robusto como Microsoft Visual Studio.

 
Xacc IDE
http://xacc.wordpress.com/
Un IDE para programar en varios lenguajes, entre ellos C#.


SharpDevelop
http://www.icsharpcode.net/opensource/sd/
Un IDE bastante completo para programar en C#, VB .Net y Boo.

MonoDevelop

http://monodevelop.com/
Es un IDE que permite crear aplicaciones .Net (ASP .Net), una alternativa a Visual Studio .Net.

Emonic (plugin para Eclipse)
 http://emonic.sourceforge.net/  
Es un plugin que se agrega Eclipse para poder crear aplicaciones C#.

Xamarin Studio
http://xamarin.com/studio
Este IDE muy  completo, con integración a Visual Studio.

domingo, 25 de mayo de 2014

Programando en Java ... no. 7

En está ocasión conoceremos algunos términos de la JEE (Java Enterprise Edition) como lo es:  Enterprise JavaBeans y Java Persistence API.


Enterprise JavaBeans

Básicamente son clases mucho más complejas que un simple POJO o un JavaBean. Deben ser contenidas y desplegadas dentro de un contenedor de EJBs, y esperan a que un "cliente" las invoque. No se pueden acceder de una manera directa desde un programa obviamente.

En la imagen se puede apreciar las funciones de cada capa del  Modelo-Vista-Controlador.

  • Dentro del modelo tendremos las Entity classes y las Sessions beans
  • El controlador se encargara de recibir peticiones de un cliente, y si encuentra el recurso, enviar respuestas a esas peticiones
  • La vista son las páginas que el usuario verá en su monitor
 
JPA... ¿Para qué sirve?
Se trata de una herramienta de mapeo objeto-relacional que nos ayuda crear una relación entre objetos y entidades de una base de datos. Forman parte del estándar EJB.

@Entity
@Table(name="blog")
public class Blog implements java.io.Serializable{
  @Id
   private Long clave;
   ...
   ...
}

EJB (Sessions beans) + JPA (Entity classes)
Al crearse las entidades se encuentran en modo desconectado,  es necesario hacer uso de las Sessions beans, las cuales se encargan de hacer las operaciones (con ayuda de de la EntityManager) de consulta, actualización y borrado.

public class BlogController{
@PersistContext
EntityManager em;
...
...
}

Las entidades JPA y los componentes EJB se configuran mediante anotaciones, y vaya que son muchas y con propósitos bien definidos.

 
Java Persistence Query Language
Se trata de un subconjunto de Hibernate Query Language, opera directamente sobre los objetos para operaciones INSERT, UPDATE, y DELETE.

SELECT b FROM  Blog b

UPDATE Blog b SET b.autor='Adriana' WHERE a.titulo='Uso de Websphere en Eclipse'

DELETE FROM Blog b WHERE b.id=1022

Métodos para ejecutar sentencias JPQL
  • createQuery(String jpql)
  • createNamedQuery(String nombre)
  • createNativeQuery(String sql)

En conclusión, hablar de EJB y JPA abarcaría mucho tiempo.Falta tratar el tema de las anotaciones, configuración de los componentes, contenedores, etc.

Espero que la imagen del Modelo-Vista-Controlador ayude un poco a entender de que tratan los EJBs.

Links
http://www.objectdb.com/
http://stackoverflow.com/questions/6033905/create-the-perfect-jpa-entity

sábado, 3 de mayo de 2014

Groovy ... en ejemplos no. 2

Groovy ... el Python de Java

1. En este ejemplo vamos a conectarnos a una base de datos (en este caso MySQL), para esto defino los siguientes pasos:

  • Crear la tabla blog e insertar algunos valores
  • Crearun archivo llamado conecta.groovy
  • Definir las librerías necesarias (y driver)
  • Escribir la consulta SQL


El código  'conecta.groovy'

@Grab('mysql:mysql-connector-java:5.1.25')
@GrabConfig(systemClassLoader = true)

import groovy.sql.Sql

static main(args) {

    def sql = Sql.newInstance('jdbc:mysql://localhost:3306/test','root','5432', 'com.mysql.jdbc.Driver')
    def consultaSQL="select * from blog"
    sql.eachRow(consultaSQL){ fila ->
        println "titulo: "+fila.titulo + " , autor: "+ fila.autor+" , descripcion: "+fila.descripcion
    }
}

Compilamos: groovyc conecta.groovy
Listamos dependencias: grape list
Ejecutamos: groovy conecta.groovy




 2. El siguiente ejemplo es sobre la interoperabilidad entre códigoJava y Groovy.

  • Creamos y compilamos  una clase Java llamada Saludo.java
  • Creamos, compilamos y ejecutamos un archivo Groovy llamado prueba.groovy
Saludo.java

 public class Saludo{
       public Saludo(){}

//método
        public static void saludo(){
        javax.swing.JOptionPane.showMessageDialog(null,"Hola desde una clase Java");
    }

}

prueba.groovy

static main(args) {
    def saludo=new Saludo()
    saludo.saludo()
}

Resultado:

A programar ...


Programando en C# no. 15: ASP .NET Core

Recordemos lo que es .NET: ".NET es una plataforma de desarrollo gratuita, multiplataforma y de código abierto para crear diversos...

Etiquetas

Archivo del blog