viernes, 18 de agosto de 2017

Java EE bajo una organización open source??


Bueno, yo pensé que Java EE de Oracle iba a ser totalmente de Oracle pero me equivoque...

Al parecer Oracle no le puede sacar dinero a Java EE y por lo tanto quiere donarlo, jeje... Digo yo.

Según lo que han publicado en el blog de la empresa, se quiere que el proceso sea más ágil y responsivo. Por lo tanto se sugiere que sea parte de un fundación open source.

Para dar un resumen concreto, luego de el desarrollo de Java EE 8, vendrá un licenciamiento más flexible y si la papa quema que la agarre el que quiera.

Dejo link:  http://www.zdnet.com/article/oracle-considers-moving-java-ee-to-an-open-source-foundation/

miércoles, 16 de agosto de 2017

OpenRA



Quiero recomendarles el Juego OpenRA que es como el Red Alert pero totalmente open source y gratuito. Esta muy bueno!! Es como viajar en el tiempo!!

Dejo link: http://www.openra.net/

domingo, 13 de agosto de 2017

Un resumen de Scala for the Impatient, parte 29


Traits o rasgos

En este capitulo vamos a ver como se trabaja con traits. Los traits son similares a las interfaces de java solo que estas puede proveer estados y comportamiento, lo que las hace más útiles.

Una clase puede implementar muchos traits
Un traits puede requerir implementar campos, métodos o súper clases
A diferencia de Java, los traits pueden implementar métodos o campos.
Cuando se superponen varios traits, el orden es importante: el trait cuyos métodos se ejecutan primero van en la parte posterior.

Por que no herencia múltiple?

Scala al igual que Java no permite que una clase herede de varias clases, esto al parecer es una restricción muy grande. Porque no debemos extender de múltiples clases. Si por ejemplo lenguajes como C++ lo permiten.

La herencia múltiple trabaja muy bien cuando se combinan clases que no tienen nada en común, pero cuando combinamos clases que tienen métodos en común se presentan diferentes problemas.
Veamos un ejemplo un asistente del profesor o alumno auxiliar :

class Student {
def id: String = …
}

class Employee {
def id: String = …
...
}

class TeachingAssistant extends Student, Employee { // Ojo que esto no compila en scala
}

Desafortunadamente TeachingAssistant tiene 2 métodos id, por lo tanto que debe hacer cuando llamamos a myTA.id, siendo myTA una instancia de TeachingAssistant. (en c++ necesitamos redefinir este método para clarificar la situación)

Ahora supongamos que tanto el empleado como el estudiante heredan de persona:

class Person {
var name: String = _
}

class Student extends Person { ... }
class Employee extends Person { ... }

Esto se denomina el problema del diamante, ahora TeachingAssistant tiene 2 campos nombre pero nosotros solo queremos uno, como se debería combinar?

En Java se decidió un camino más restrictivo para resolver estos problemas, no se permite herencia múltiple de clases pero se invento el concepto de interfaz que no permite que se implementen métodos y no puede contener atributos pero puede ser heredado de forma múltiple.

Scala no permite herencia múltiple pero tiene los traits o rasgos. Un trait puede contener métodos abstractos o concretos y estados y una clase puede implementar múltiples traits. Ahora veremos como scala resuelve los conflictos de implementación.

Traits como interfaces Java

Los traits puede ser utilizadas de igual manera que las interfaces de Java:

trait Logger {
def log(msg: String) // Método abstracto
}

No es necesario indicar que este método es abstracto, si no se implementa en un trait es automáticamente abstracto.

Y una clase puede proveer una implementación:

class ConsoleLogger extends Logger { // Se usa extends y no implements
def log(msg: String) { println(msg) } // No es necesario el override
}
No es necesario agregar override cuando se sobrescribir un método abstracto de un trait.

Si es necesario agregar más interfaces, se debe hacerlo con la palabra clave with :

class ConsoleLogger extends Logger with Cloneable with Serializable


Como se puede ver se están utilizando interfaces Cloneable y Serializable que son de Java, sin ningún problema.  

martes, 8 de agosto de 2017

Nuevo centro de contenido de MongoDB

Me llego el siguiente mail, y quería compartirlo con ustedes:

Visite nuestro nuevo centro de contenido 

Hola, 

Visite nuestro centro de contenido para ver todas las novedades sobre MongoDB, NoSQL y últimas tendencias en programación. 

En nuestro centro de contenido podrá encontrar información sobre los siguientes temas:
  • Casos de cliente, productos y arquitectura de MongoDB
  • Big Data
  • Internet of Things
  • Análisis en tiempo real con Apache Spark

Visitar el centro

En nuestro centro de contenido tiene a su disposición vídeos, artículos y libros, todo en un mismo lugar. 

Reciba un cordial saludo,

El equipo de MongoDB
 
 Share on TwitterShare on FacebookShare on LinkedInShare on Google+ 
 
MongoDB Inc., 2017. Todos los derechos reservados.
Palacio de Miraflores, Suite 219 & 220, Carrera de San Jerónimo 15 - 2, Madrid 28014, Spain

Para darse de baja de futuros mensajes de MongoDB o para actualizar sus preferencias de correo electrónico haga clic aquí.
 

domingo, 6 de agosto de 2017

Un resumen de Scala for the Impatient, parte 28

Expresiones Regulares

Cuando tomamos un texto como entrada podemos utilizar expresiones regulares para analizarlos. La clase scala.util.matching.Regex nos puede facilitar las cosas, para construir este objeto, se puede utilizar el método r de la clase String:

val numPattern = "[0-9]+".r

Si la expresión regular contiene barras invertidas o comillas, entonces es una buena idea usar la sintaxis de cadena "raw", "" "..." "". Por ejemplo:

val wsnumwsPattern = """\s+[0-9]+\s+""".r
// A bit easier to read than "\\s+[0-9]+\\s+".r

El metodo findAllIn retorna un iterador que itera por todas las coincidencias. Y esto se puede utilizar en un for :

for (matchString <- numPattern.findAllIn("99 bottles, 98 bottles"))
   process matchString

O podemos retornar un arreglo con toArray :

val matches = numPattern.findAllIn("99 bottles, 98 bottles").toArray
// Array(99, 98)

Si buscamos solo el primer elemento que coincida, podemos utilizar el método findFirstIn. Que retorna un Option[String]

val m1 = wsnumwsPattern.findFirstIn("99 bottles, 98 bottles")
// Some(" 98 ")

Para comprobar si el principio de una cadena coincide, utilice findPrefixOf:

numPattern.findPrefixOf("99 bottles, 98 bottles")
// Some(99)
wsnumwsPattern.findPrefixOf("99 bottles, 98 bottles")
// None

Si se desea remplazar la primera coincidencia o todas las coincidencias:

numPattern.replaceFirstIn("99 bottles, 98 bottles", "XX")
// "XX bottles, 98 bottles"
numPattern.replaceAllIn("99 bottles, 98 bottles", "XX")
// "XX bottles, XX bottles"

Grupos de expresiones regulares.

Los grupos son útiles para obtener subexpresiones de expresiones regulares. Añada paréntesis alrededor de las subexpresiones que desea extraer, por ejemplo:

val numitemPattern = "([0-9]+) ([a-z]+)".r

Para hacer coincidir los grupos, utilice el objeto de expresión regular como un "extractor":

val numitemPattern(num, item) = "99 bottles"
// Sets num to "99", item to "bottles"

Si desea extraer grupos de coincidencias múltiples, utilice una instrucción for de este modo:

for (numitemPattern(num, item) <- numitemPattern.findAllIn("99 bottles, 98 bottles"))
    process num and item

Un resumen de Scala for the Impatient, parte 27



Revisar un directorios.

No existe una clase oficial para revisar directorios en carpetas pero vamos a ver algunas alternativas.

Es muy simple escribir una función que recorra todas las carpetas y subcarpetas:

import java.io.File
def subdirs(dir: File): Iterator[File] = {
    val children = dir.listFiles.filter(_.isDirectory)
    children.toIterator ++ children.toIterator.flatMap(subdirs _)
}

Con esta función se puede visitar todos los subdirectorios:

for (d <- subdirs(dir)) process d

Si utilizamos Java 7, se puede utilizar el metodo walkFileTree de la clase java.nio.file.Files. Esta clase hace uso de la interfaz FileVisitor. En scala se prefiere utilizar funciones de objetos y no interfaces. Por lo tanto podemos adaptar esta funcionalidad a una visión más scala:

import java.nio.file._
implicit def makeFileVisitor(f: (Path) => Unit) = new SimpleFileVisitor[Path] {
    override def visitFile(p: Path, attrs: attribute.BasicFileAttributes) = {
        f(p)
        FileVisitResult.CONTINUE
    }
}

Por lo tanto se pueden imprimir todos los directorios de esta manera:

Files.walkFileTree(dir.toPath, (f: Path) => println(f))

Si se quiere realizar otra acción, se pasara otro método y no println

Serialización. 

Esto no tiene ninguna relación con los cereales (jeje). En Java, la serialización es utilizada para cuando queremos transmitir un objeto a otra maquina virtual o para guardar el objeto por un tiempo mínimo.

En scala se puede utilizar el mismo mecanismo pero su declaración es un tanto diferente:

Java:
public class Person implements java.io.Serializable {
    private static final long serialVersionUID = 42L;
    …
}

Scala:
@SerialVersionUID(42L) class Person extends Serializable

El Trait Serializable esta definido en el paquete scala por lo que no es necesario ningún import.
Si nos olvidamos de @SerialVersionUID este tomara un valor por defecto.

Serializar y desserializar un objeto es similar a Java:

val fred = new Person(...)
import java.io._
val out = new ObjectOutputStream(new FileOutputStream("/tmp/test.obj"))
out.writeObject(fred)
out.close()
val in = new ObjectInputStream(new FileInputStream("/tmp/test.obj"))
val savedFred = in.readObject().asInstanceOf[Person]

En scala las colecciones son seriabilizables por lo que se pueden utilizar como atributos de objetos seriabilizables:

class Person extends Serializable {
    private val friends = new ArrayBuffer[Person] // OK—ArrayBuffer is serializable
    …
}

Procesos de control

Tradicionalmente los administradores de sistema utilizan un script de shell para hacer tareas de mantenimiento como mover archivos o combinarlos. Los lenguajes script hacen fáciles estas tareas pero como lenguajes de programación dejan mucho que desear.

Scala fue diseñado para poder hacer desde humildes script a grandes aplicaciones. El paquete scala.sys.process provee utilidades para interactuar con programas shell. Es decir que podemos escribir programas tipo shell con scala.

Veamos un ejemplo simple:

import sys.process._
"ls -al .." !

Como resultado obtendremos el listado de todos los archivos del directorio. sys.process tiene un convertidor implícito de string al objeto ProcessBuilder. Y con el operador ! ejecutamos el comando.

El resultado del operador ! es un numero entero que si es 0 el comando tuvo éxito y si es distinto de 0, no.

Si utilizamos el operador !! esto retornara un string :

val result = "ls -al .." !!

Se puede utilizar este resultado como entrada de otros programas con el operador |# que es similar al operador | de linux:

"ls -al .." #| "grep sec" !

Se puede redireccionar la salida con el operador #>

"ls -al .." #> new File("output.txt") !

Si se desea que se agregar en el archivo se puede utilizar #>>

"ls -al .." #>> new File("output.txt") !

Y si se desea introducir una estrada se debe utilizar #<

"grep sec" #< new File("output.txt") !

Se puede introducir un input desde una URL :

"grep Scala" #< new URL("http://horstmann.com/index.html") !
 
Notemos que los operadores de scala se diferencian de los operadores bash solo porque comienzan con el carácter #.

sábado, 5 de agosto de 2017

Java y C caen en popularidad según el indice Tiobe

Bueno, yo la vi venir, los grandes ganadores en el indice Tiobe de los últimos años han bajado. Java y C han bajado bastante no para dejar el podio pero ha sido una gran sacudida, dado que venían estables o creciendo.

Si bien no soy capaz de opinar sobre C, me atrevo a opinar de Java y creo que la principal razón de su caída son :

  • Los nuevos lenguajes que tiene la plataforma, como Kotlin, Scala, Groovy, Clojure y etc. Recordemos que ahora Kotlin es un lenguaje oficial para android. 
  • La plataforma .net esta ganando un lugar en el open source con .net core

Pero esta es solo mi opinión, veamos los números de agosto:


  • Java (12.961%)
  • C (6.477%)
  • C++ (5.55%)
  • C# (4.195%)
  • Python (3.692%)
  • Visual Basic .Net (2.569%)
  • PHP (2.293%)
  • JavaScript (2.098%)
  • Perl (1.995%)
  • Ruby (1.965%)
Claramente no se ve mucho la evolución pero en este gráfico queda super claro: 



Lo extraño es que no hay un claro ganador, es como que se diversifico. Sera el fin de Java? Que piensan?

Dejo link:
https://www.tiobe.com/tiobe-index/
http://www.infoworld.com/article/3212970/application-development/java-and-c-hit-all-time-lows-in-tiobe-language-popularity-index.html

jueves, 3 de agosto de 2017

Donar

Agregue al Blog un botón para que puedan hacer donaciones al mismo, la idea es que con esas donaciones pueda comprar libros, hacer cursos y por supuesto que esto quede reflejado en el blog.

Si piensas que esto debe o puede mejorar o estas conforme pero quiere ir por más, dona unas divisas para poder seguir mejorando.

Saludos y gracias!!

martes, 1 de agosto de 2017

Un resumen de Scala for the Impatient, parte 26



Leer una linea de archivo

Leer todas lineas desde un archivo, puede llamar al método getLine del Objeto scala.io.Source :

import scala.io.Source
val source = Source.fromFile("myfile.txt", "UTF-8")
// El primer argumento va ser un string or java.io.File
val lineIterator = source.getLines

El resultado es un iteraror que permite procesar las lineas:

for (l <- lineIterator) process l

o se puede volcar las lineas en un arreglo o en un buffer :

val lines = source.getLines.toArray

Algunas veces deseamos volcar el contenido de un archivo en un string, lo podemos hacer con :

val contents = source.mkString

Ojo! Cuando terminamos de usar source debemos cerrarlo.

Para leer caracteres podemos utilizar directamente source e iterar por le mismo:

for (c <- source) process c

Si deseamos leer un archivo (como istream :: peek en C ++ o PushbackInputStreamReader en Java), llama al método buffered en el origen

val source = Source.fromFile("myfile.txt", "UTF-8")
val iter = source.buffered
while (iter.hasNext) {
    if (iter.head is nice)
        process iter.next
    else
        …
}
source.close()

Veamos como podemos leer un todos lo espacios en nuestro código:

val tokens = source.mkString.split("\\s+")

Para convertir un String a entero o flotante se puede utilizar los métodos toInt o toDouble

Si necesitamos leer un entero desde la consola, podemos hacer lo siguiente:

print("Cuntos años tienes? ")
val age = readInt()
// O podemos usar readDouble o readLong

Este comando asume que el usuario ingresará un numero y si no lo hace se lanzara NumberFormatException

Leer url o otros recursos. 

Para leer desde una Url o algun otro recurso podemos utilizar Source de la siguiente manera:

val source1 = Source.fromURL("http://horstmann.com", "UTF-8")
val source2 = Source.fromString("Hello, World!")
// lee desde un string, puede ser util para cuando se esta debugeando
val source3 = Source.stdin
// lee desde la entrada estandar

Leer archivos Binarios. 

Para leer archivos binarios debemos utilizar la librería estándar de java. Veamos como podemos leer un archivo binario a un array de bytes:

val file = new File(filename)
val in = new FileInputStream(file)
val bytes = new Array[Byte](file.length.toInt)
in.read(bytes)
in.close()

Escribir un archivo de texto. 

Scala no tiene un objeto o función especial para escribir archivos, debemos utilizar la librería de java. Por ejemplo:

val out = new PrintWriter("numbers.txt")
for (i <- 1 to 100) out.println(i)
out.close()

Todo funciona como se esperaba, excepto para el método printf. Cuando pasa un número a printf, el compilador se quejará de que necesita convertirlo a un AnyRef:

out.printf("%6d %10.2f",
 quantity.asInstanceOf[AnyRef], price.asInstanceOf[AnyRef])

pero podemos usar el método de formato de la clase String:

out.print("%6d %10.2f".format(quantity, price))