jueves, 31 de julio de 2014

Introduction to Linux

"Introduction to Linux" es un curso super recomendado para todos los que aman el sistema operativo Linux. Esta dictado por el mismísimo Linus Tolvar y se dicta por medio de la pagina Edx.

Dejo un vídeo:


Dejo link:
https://www.edx.org/course/linuxfoundationx/linuxfoundationx-lfs101x-introduction-1621#.U9rn_x8zzpq

Tutorial de Python en Español Por Python Argentina


La verdad es que estoy robando esta información a Chema Cortés, gracias a él encontré este excelente tutorial de Python hecho por la gente de Python Argentina.

Sin otro particular les dejo el link:
http://docs.python.org.ar/tutorial/index.html

martes, 29 de julio de 2014

OpenSUSE Factory se convierte en distro rolling release


Que buena distro OpenSUSE!!

OpenSUSE tiene una distro hermanita o hija OpenSUSE Factory que es la rama de desarrollo de OpenSUSE. Esta distro a optado por ser rolling release.

Sin más les presento esta distro:

"La distribución Factory es una distribución de desarrollo continuo (rolling) y la base para la próxima publicación estable de openSUSE.
Hay un flujo constante de paquetes entrando en Factory. No hay congelaciones y, por tanto, el repositorio Factory no ofrece garantías de ser completamente estable. Los paquetes fundamentales del sistema se testan usando openQA. Cuando se completa el test automatizado y el repositorio se encuentra en un estado estable, éste se sincroniza con los servidores réplica para la descarga. Esto sucede una o dos veces por semana.
Factory es mayormente útil para los desarrolladores principales de la distribución, testeadores con experiencia y desarrolladores que quieren estar al filo de la navaja.
Se avisa a los usuarios corrientes de que se mantengan en la versión estable. "

Dejo link:
http://es.opensuse.org/Portal:Factory

domingo, 27 de julio de 2014

Aprendiendo Node.js


Quiero compartir el siguiente libro que encontré sobre Node.js.

Dejo link: http://www.creativealys.com/2014/07/27/learning-node-js/

Desarrollo en Android y IOS con F#

Sin duda la programación funcional cada vez esta ganando más espacio, la noticia de hoy tiene que ver con esto.

F# ahora esta soportado para las plataformas Android y IOS gracias a la gente de Xamarin. A partir de la versión Xamarin 4.8 podemos utilizar F# para desarrollar aplicaciones Android y IOS. Les recuerdo que Xamarin es la empresa que llevo a C# a Android y la principal promotora de Mono.

Y para el que no sabe, F# (pronunciado F Sharp) es un lenguaje de programación multiparadigma de código abierto, para la plataforma .NET, que conjunta la programación funcional con las disciplinas imperativa y orientada a objetos. Es una variante del lenguaje de programación ML y es compatible con la implementación Objective Caml. F# fue inicialmente desarrollado por Don Syme de Microsoft Research, pero actualmente está siendo desarrollado por la División de Desarrolladores de Microsoft y es distribuido como un lenguaje totalmente soportado en la plataforma .NET y Visual Studio 2010, 2012 y 2013.

Dejo link:
http://www.infoq.com/news/2014/07/fsharp-native-moible-development

martes, 22 de julio de 2014

Programación con Qt4

Por motivos personales decidí aprender un poco más de qt plataforma que siempre me gusto pero nunca le pude dedicar tiempo. Estuve buscando algunos libros y me encontre con estos:
  • Advanced Qt Programming Creating Great Software with C++ and Qt 4 
  • An Introduction to Design Patterns in C++ with Qt 
  • C++ GUI Programming with Qt 4 
  • Foundations of Qt Development 
Les dejo el link:

Introduction to Multitenant Databases

Me llego un mail de la gente de oracle invitandome a un Webinar. Parece interesante por lo tanto quiero compartir la invitación:


Free Live Web Seminar
Introduction to Multitenant Databases
Wednesday, July 30
9:00am to 10:00am PT
(12:00pm to 1:00pm ET)
 
Sign up Now!


About the Instructor

Bill Millar
Bill Millar is a Senior Principal Instructor for Oracle University. Bill has been an instructor with Oracle for over 7 years with a focus on database administration courses. Bill teaches Oracle Database Installation and Administration, Backup and Recovery, Performance Tuning, Oracle Database 12cNew features and Managing Multitenant Architecture.

Free Oracle Learning Streams Live Webinar!
Introduction to Multitenant Databases
Introduction to Multitenant Databases

Oracle University is pleased to invite you to experience part of the new Oracle Database Learning Stream when you attend this free one-hour webinar delivered by one of our senior instructors, Bill Millar. In this webinar, Bill will provide an overall understanding of the multitenant architecture, including how to create and manage a multitenant container database and pluggable databases. Bill will also explore how to create and manage storage, apply security and best practices.This Live Webinar Includes:
  • Multitenant Architecture
  • Creating Multitenant and Pluggable Database
  • Managing Storage
  • Applying Security
  • Best Practices
  • Preview of Oracle Learning Streams
Why You Should Attend:
By attending this live webinar, you will get overall understanding of the multitenant architecture. Sign Up Now.

Discover Oracle Learning StreamsSubscribe to Oracle Learning Streams to receive one year of unlimited access to:
  • Hundreds of fresh videos and webinars by Oracle experts
  • Live connections with Oracle's top instructors
  • Robust video search capability to find exactly what you are looking for
  • Tools to build your own custom learning queue and request new content
For a limited time save 50% when you purchase an Oracle Learning Stream subscription together with any Oracle University Classroom, Live Virtual Class or Training On Demand training.*

Learn More
Hardware and Software, Engineered to Work TogetherOracle University
Copyright © 2014, Oracle and/or its affiliates.
All rights reserved.
Contact Us | Legal Notices | Privacy

domingo, 20 de julio de 2014

Lista por comprensión


¿Recuerdan de las definiciones matemáticas de por ejemplo números pares o múltiplos que veíamos en la escuela? por ejemplo la definición de los números pares mayores a 10 sería así:

s = { 2 * x  | x  € N, 2 * x > 10 }

Esto se lee como los números pares (2*x) que pertenecen (€) a los números naturales (N) y que sean mayores que 10.  La parte anterior al separador se llama la función de salida, x es la variable, N es el conjunto de entrada y  2 * x > 10 es el predicado.




De esta forma se define la lista de forma compresiva. Es decir se puede conocer el valor de la lista dependiendo de la posición sin enumerar sus elementos. Esta definición se podría escribir en Haskell de la siguiente manera:

s = [ 2*x | x <- [0..], x*2 > 10 ]

Como vemos es muy similar a la definición matemática, solo que se define los números naturales como [0..] los dos puntos indican que esta lista es infinita. Cuando pensamos en una lista infinita, automáticamente relacionamos con un bucle que nunca termina o con un cuelgue de nuestro programa, esto es porque venimos del mundo imperativo pero cómo Haskell ejecuta las sentencias de forma perezosa, podemos modelar listas infinitas sin problema.

Podemos modelar diferentes listas sin ningún problema, por ejemplo  todos los números del 50 al 100 cuyo resto al dividir por 7 fuera 3 :

ghci> [ x | x <- [50..100], x `mod` 7 == 3]
[52,59,66,73,80,87,94]

La lista de dobles de los números naturales y que el cuadrado sea mayor a 3:

s = [ 2*x | x <- [0..], x^2 > 3 ]

Por suerte las listas por compresión, no son solo una característica de Haskell sino que se encuentra en diferentes lenguajes, voy a mostrar el ejemplo de la lista de dobles de los números naturales y que el cuadrado sea mayor a 3 en diferentes lenguajes:

Ceylon
{ for (x in 0..100) if ( x**2 > 3) x * 2 }

Clojure
 (take 20
   (for [x (range) :when (> (* x x) 3)]
     (* 2 x)))
 ;; ⇒ (4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40 42)

CoffeeScript
 (x * 2 for x in [0..20] when x*x > 3)

Elixir
for x <- 0..100, x*x > 3, do: x*2

Erlang
 S = [2*X || X <- lists:seq(0,100), X*X > 3].

F#
> seq { for x in 0..100 do
          if x*x > 3 then yield 2*x } ;;
val it : seq<int> = seq [4; 6; 8; 10; ...]

Groovy
s = (1..100).grep { it ** 2 > 3 }.collect { it * 2 }
s = (1..100).grep { x -> x ** 2 > 3 }.collect { x -> x * 2 }

JavaScript 1.7
 js> [2*x for each (x in [0,1,2,3,4,5,6,7]) if (x*x<5)]
 [0, 2, 4]

Julia
y = [x^2+1 for x in 1:100]

Perl 6
my @s = ($_ * 2 if $_ ** 2 > 3 for ^100);

Python
S = [2 * x for x in range(101) if x ** 2 > 3]

Scala
val s = for (x <- Stream.from(0) if x*x > 3) yield 2*x

Smalltalk
((1 to: 100) select: [:x|x*x>3]) collect: [:x|2*x]

Algunos lenguajes tienen diferentes formas de hacer lo mismo y para algunos lenguajes no uso todos los números naturales sino hasta el 100.

En resumen podemos decir que las listas por comprensión es una característica de algunos lenguajes con lo cual podemos definir listas de forma comprensiva.

Dejo link: http://en.wikipedia.org/wiki/List_comprehension

jueves, 17 de julio de 2014

Eclipse Luna esta aquí!!


Se me paso totalmente el lanzamiento de Luna la nueva versión de mi IDE favorita eclipse. Entre las características más importantes de este IDE es soporte completo a java 8.

miércoles, 16 de julio de 2014

Resolviendo problemas de forma funcional


Pensar de forma funcional es bastante difícil y más que nada si estamos programando en otro paradigma. Por lo tanto la idea es plantear un problema y buscar una solución funcional.

Problema

Normalmente cuando escribíamos expresiones matemáticas en la escuela lo hacíamos de forma infija. Por ejemplo, 10 -(4 + 3) * 2. +, * y - son operadores infijos. Resulta bastante útil, ya que nosotros, como humanos, podemos analizar fácilmente estas expresiones. Lo malo es que tenemos que utilizar paréntesis para especificar la precedencia.

La Notación polaca inversa (RPN) es otra forma de escribir expresiones matemáticas. Al principio parece un poco complicado, pero en realidad es bastante fácil de entender y utilizar ya que no hay necesidad de utilizar paréntesis y muy fácil de utilizar en la calculadoras. Aunque las calculadoras más modernas usan una notación infija, todavía hay gente que lleva calculadoras RPN (del inglés, Reverse Polish Notation). Así se vería la expresión infija anterior en RPN:

10 4 3 + 2 * -

¿Cómo calculamos el resultado de esto? Bueno, piensa en una pila. Recorremos la expresión de izquierda a derecha. Cada vez que encontramos un número, lo apilamos. Cuando encontramos un operador, retiramos los dos números que hay en la cima de la pila, utilizamos el operador con ellos y apilamos el resultado de nuevo. Cuando alcancemos el final de la expresión, debemos tener un solo número en la pila si la expresión estaba bien formada, y éste representa el resultado de la expresión.

Si no estas pensando en Lisp, no tuviste infancia o tuviste una infancia feliz.  En Lisp, el primer elemento de cada expresión es un operador y el resto de elementos son tratados como datos. Esta forma se denomina notación prefija o notación Polaca Cambridge. Lisp no utiliza la notación polaca inversa, usa la notación prefija de esta forma tampoco es necesario especificar la precedencia.

Pero sigamos con el problema, vamos a pensar en como podríamos hacer que una función tomara como parámetro una cadena que contenga una expresión RPN, como 10 4 3 + 2 * -, y nos devolviera el resultado.

Solución

Antes que nada para trabajar más cómodos necesitamos una lista que contenga los operadores y operandos, por lo tanto debemos tomar la cadena “10 4 3 + 2 * -” y separarla por los espacios y luego llevarla a una lista.

Cuando implementemos la solución de un problema, a veces es bueno ver como lo solucionamos de forma manual para ver si podemos sacar algo que nos ayude. Por lo tanto vamos a resolver la expresión “10 4 3 + 2 * -” de forma manual.

Como dijimos anteriormente llevamos “10 4 3 + 2 * -” a una lista. Luego tomamos el primer elemento y lo apilamos de forma que ahora nuestra pila contiene un 10. El siguiente elemento es un 4, así que lo apilamos también. La pila ahora contiene 10, 4. Hacemos los mismo para el 3 y conseguimos una pila que contiene 10, 4, 3. Ahora, encontramos un operador, +. Retiramos los dos números que se encuentran en la cima de la pila (de forma que la pila se quedaría de nuevo solo con 10), sumamos esos dos números y apilamos el resultado. La pila contiene 10, 7 ahora mismo. Apilamos 2 y obtenemos 10, 7, 2. Multiplicamos 7 y 2 y obtenemos 14, así que lo apilamos y la pila ahora contendrá 10, 14. Para terminar hay un -. Retiramos 10 y 14 de la pila, restamos 14 a 10 y apilamos el resultado. El número que contiene la pila es -4 y como no hay más números ni operadores en la expresión, ese es el resultado.

¿Qué fue lo hicimos? Recorrimos la expresión de izquierda a derecha mientras manteníamos una pila.

Lo primero que podemos pensar es en los casos especiales, ¿que deberíamos hacer si la lista de operadores y operandos esta vacía? En ese caso deberíamos devolver la pila, la pila debería tener un elemento, pero esta validación escapa del ejercicio. Si tiene un elemento debemos analizar que es ese elemento si es un operador debemos tomar los dos elementos de la pila, luego aplicar el operador y por ultimo apilar el resultado. Si es un operando debemos simplemente apilarlo.

Una cosa más que tenemos que pensar es, bueno ¿Cómo vamos a representar la pila? Propongo que utilicemos una lista. También propongo que mantengamos en la cabeza de la lista la cima de la pila. De esta forma añadir un elemento en la cabeza de la lista es mucho más eficiente que añadirlo al final. Así que si tenemos una pila como, 10, 4, 3, la representaremos con una lista como [3,4,10].

Ahora tenemos suficiente información para bosquejar vagamente nuestra función. Tomará una cadena como "10 4 3 + 2 * -" y la romperá en una lista de elementos utilizando words de forma que obtenga ["10","4","3","+","2","*","-"]. Luego, utilizará un pliegue por la izquierda sobre esa lista y generará una pila con un único elemento, como [-4]. Tomará ese único elemento de la lista y ese será nuestro resultado final.

Veamos el código en scala:

//Paso la cadena a una lista  
val valores = "10 4 3 + 2 * -".split(" +").toList
   
   
 def eval(valores : List[String], pila:List[String]) : List[String] = valores match {
  case Nil => pila
  case x :: xs => x match {
  case "+" => eval(xs, (pila(1).toInt + pila.head.toInt).toString :: pila.tail.tail)
  case "-" => eval(xs, (pila(1).toInt - pila.head.toInt).toString :: pila.tail.tail)
  case "*" => eval(xs, (pila(1).toInt * pila.head.toInt).toString :: pila.tail.tail)
  case _ => eval(xs, x :: pila )
  }
}  

eval(valores, Nil)                            
> res0: List[String] = List(-4)

Como podemos ver usando funciones recursivas podemos recorrer la lista con operadores y operandos.

Otra forma de recorrer una lista muy fácilmente es por medio de los pliegues. Con los pliegues podemos implementar cualquier función que recorra una lista de izquierda a derecha, elemento a elemento, y genere (o acumule) un resultado.

En este caso, vamos a utilizar un pliegue por la izquierda, ya que vamos a recorrer la lista de izquierda a derecha.

Veamos la solución con pliegues:

def eval2(pila:List[String], x: String) : List[String] = x match {
  case "+" =>  (pila(1).toInt + pila.head.toInt).toString :: pila.tail.tail
  case "-" =>  (pila(1).toInt - pila.head.toInt).toString :: pila.tail.tail
  case "*" =>  (pila(1).toInt * pila.head.toInt).toString :: pila.tail.tail
  case _ => x :: pila
}                                                


valores.foldLeft(List[String]()) (eval2)        
> res1: List[String] = List(-4)

o la versión resumida usando clausuras:

"10 4 3 + 2 * -".split(" +").toList.foldLeft(List[String]()) ((pila:List[String], x: String) => x match {
  case "+" =>  (pila(1).toInt + pila.head.toInt).toString :: pila.tail.tail
  case "-" =>  (pila(1).toInt - pila.head.toInt).toString :: pila.tail.tail
  case "*" =>  (pila(1).toInt * pila.head.toInt).toString :: pila.tail.tail
  case _ => x :: pila
})

Como ven podemos resolver el problema utilizando pattern matching y pliegues o funciones recursivas.

Que opinan? se puede mejorar la solución?

Developing Android Apps

Udacity lanzo un curso gratuito muy interesante de Android. Aun que cuesta 150 dolares tener correcciones personalizadas y "trato" especial, el curso es gratuito.

Les dejo un vídeo:



Dejo link:
https://www.udacity.com/course/ud853

martes, 15 de julio de 2014

Debian AIO: todos los sabores de Debian en un solo disco


Robe este post, es de http://lamiradadelreplicante.com/

Quiero hacerme eco de esta super version de Debian que permite probar todos los sabores del sistema operativo. Debian Live AIO DVD es un proyecto no oficial de Debian que incluye todas las ISOs de los principales entornos presentes en esta distribución GNU/Linux, como son KDE, GNOME, Xfce y LXDE, en un único archivo.

Dejo el link, del post original:
http://lamiradadelreplicante.com/2014/07/14/debian-aio-todos-los-sabores-de-debian-en-un-solo-disco/

sábado, 12 de julio de 2014

Entendiendo el principio HATEOAS


HATEOAS es la abreviación de Hypermedia as the Engine of Application State (hipermedia como motor del estado de la aplicación). Es una restricción de la arquitectura de la aplicación REST que lo distingue de la mayoría de otras arquitecturas. El principio es que un cliente interactúa con una aplicación de red completamente a través de hipermedia proporcionadas dinámicamente por los servidores de aplicaciones. Es como que el cliente REST debe ir navegando por la información y no necesita ningún conocimiento previo acerca de la forma de interactuar con cualquier aplicación o servidor más allá de una comprensión genérica de hipermedia.

En otras palabras cuando el servidor nos devuelva la representación de un recurso parte de la información devuelta serán identificadores únicos en forma de hipervínculos a otros recursos asociados.

Lo vamos a entender mejor con un ejemplo, supongamos que tenemos una API REST, con cliente y sus diferentes pedidos. El modelo podría ser un cliente que tenga una lista de pedidos.

Lo que podríamos hacer es cuando el cliente REST solicite un cliente por la URI:

myURL/cliente/:id

Devolvemos los datos del cliente con su lista de pedidos. Pero el problema yace en que tal vez tenga muchos pedidos y a la vez el cliente REST necesita datos del cliente no de los pedidos. Por lo tanto, estoy mostrando más información de lo que debiera.

Una solución sería tener otro servicio REST que me devuelva los pedidos, por ejemplo:

myURI/cliente/2

Esta URI me devolverá los datos del cliente 2 que podría ser:

{ id:2, nombre:”Pepe”, apellido:”Gomez” }

Y podríamos hacer otro servicio que nos devuelva los pedidos por medio de la URI:

myURI/cliente/2/pedidos

Supongamos que por algún problema debemos cambiar la URI de pedidos, para hacer esto  debemos avisar a todos los clientes y ellos deberán consumir la nueva URI.

HATEOAS nos dice que debemos mostrar las URIs de forma que el cliente este menos acoplado al servidor y no sea necesario hacer cambios en estos casos.

Por ejemplo el servicio de consulta de clientes puede devolver la URI del pedido de la siguiente manera:

{ id:2, nombre:”Pepe”, apellido:”Gomez” , pedidos:”myURL/cliente/2/pedidos ”}

A la vez si no mostramos la URI de los pedidos el cliente REST tiene que ir a la documentación de la API por cada servicio que desee utilizar. Con HATEOAS los servicios descubren nuevos servicios lo que permite navegar por la información y un cliente que una URI principal puede ir descubriendo los demás servicios.  

La restricción HATEOAS desacopla cliente y el servidor de una manera que permite la funcionalidad del servidor para evolucionar de forma independiente.

Dejo link: http://en.wikipedia.org/wiki/HATEOAS

Mint Xfce

Todos sabrán mi adoración por el sistema operativo Mint, me parece que hace las cosas muy bien y me gusta mucho la interfaces mate y cinammon. Pero ahora les quiero mostrar Mint xfce. Para el que no conoce xfce es una interfaces de escritorio muy liviana y potente, la que la gente de Mint la volvió muy elegante.

Les cuento tal cual fue mi encuentro con esta versión, andaba buscando un escritorio liviano para una pc vieja que tengo y siendo sincero quede maravillado, tanto que lo voy a usar en mi actual pc.

Les dejo screenshots:






Dejo link:
http://www.linuxmint.com/


jueves, 10 de julio de 2014

Bootstrap 3, el manual oficial


Bootstrap 3 es un framework front-end para desarrollo web, enfocado en responsive design. Si no lo conoces deberías hacerlo ya que es de gran utilidad.

Me encontré este manual que me pareció bien compartirlo:

http://librosweb.es/bootstrap_3/

A estudiar!!!

martes, 8 de julio de 2014

Hacer una Api Rest con haskell es posible gracias a rest


Parece un juego de palabras pero no lo es rest es un framework (en la documentación dice conjunto de paquetes) que permiten hacer una Api Rest con Haskell.

A la vez se puede ejecutar estas librerías en varios frameworks web, como Happstack o Snap. También puede generar automáticamente la documentación de la API Rest, lo que garantiza que siempre coincide con el código. Del mismo modo, puede generar cliente para diferentes lenguajes como Javascript o Haskell.

Algo muy bueno es que la Api queda escrita como en un DSL muy fácil de mantener, veamos un ejemplo:

module Api.Post (resource) where

import Rest
import qualified Rest.Resource as R

type Title = String

resource :: Resource IO (ReaderT Title IO) Title () Void
resource = mkResourceReader
  { R.name   = "post"
  , R.schema = withListing () $ named [("title", singleBy id)]
  , R.list   = const list
  , R.get    = Just get
  }

Dejo link:
http://silkapp.github.io/rest/
https://github.com/silkapp/rest/archive/master.zip

sábado, 5 de julio de 2014

The Eclipse Memory Analyze, una excelente herramienta para buscar memory leak


Si no sabes que es un memory leak siéntete un afortunado, dado que estos nos hacen la vida imposible cuando suceden. Como sabrán java tiene un Garbage collector o recolector de basura que se encarga de eliminar los objetos que no utilizamos y liberar la memoria.

Pero cómo sabe cuándo no usamos más un objeto? Una posibilidad es cuando nadie lo referencia. En el heap de la Máquina Virtual Java (JVM) guarda todos los objetos creados por la aplicación Java, por ejemplo, utilizando el operador "new". El recolector de basura de Java puede separar lógicamente el heap en diferentes áreas, por lo que el garbage collector puede rápidamente identificar los objetos que pueden quedar eliminados.

La memoria para los nuevos objetos se asigna en el heap en tiempo de ejecución. Las variables de instancia viven en el interior del objeto en el que se han declarado. Por lo tanto, si referenciamos siempre a un objeto por más que no lo usemos el garbage collector no lo va a poder eliminar. Si creamos objetos y no los liberamos nunca vamos a consumir cada vez más memoria y este es un recurso limitado por lo que tarde o temprano vamos a tener un OutOfMemoryError. Es decir nos, quedamos sin memoria.

Algo horrendo en la vida de un programador, es buscar este tipo de errores. Son muy difíciles de rastrear y muchas veces ocurren cuando la aplicación tiene tiempo corriendo.

Para ayudarnos a luchar contra los memory leak, eclipse creo MAT o The Eclipse Memory Analyze que es un rápido y seguro analizador de memoria java. Que necesitamos para utilizarlo? Solamente un dump de memoria cuando ocurra el error. Si, si claro y como obtengo esto?

Es muy fácil, para obtener un dump de memoria cuando ocurre un OutOfMemoryError debemos configurar la jvm con unos parámetros como lo indica la documentación de oracle:

-XX:-HeapDumpOnOutOfMemoryError que indica a la Jvm que haga un dump cuando ocurra un OutOfMemoryError

-XX:HeapDumpPath=./java_pid<pid>.hprof que indica donde va a guardarse el dump, no es obligatorio pero es aconsejable configurar el path para estar seguros donde se va a guardar.

Por ejemplo con:

Java -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/home/emanuelpeg/logs/

Le estoy diciendo a la jvm que guarde el dump de memoria en /home/emanuelpeg/logs/ cuando ocurra un OutOfMemoryError.

Luego de esto es todo muy fácil, solo tenemos que importar el dump a MAT y esta herramienta nos preguntará si queremos hacer un reporte con los memory leaks y simplemente tenemos que presionar finish para obtener un completo reporte interactivo de la memoria de la jvm.



A la vez nos brinda gráficos con los posibles errores, y contiene un histograma el cual muestra el número de instancias de una clase en particular y la cantidad de memoria que cada uno utiliza. Además, se puede agrupar por cargador de clase o paquete. Esto le permitirá centrarnos en nuestros objetos.


Como conclusión podemos asegurar que MAT es una herramienta indispensable para la búsqueda de memory leaks.

 Dejo link: http://www.eclipse.org/mat/

jueves, 3 de julio de 2014

Scala.js


Scala.js es un compilador scala a javascript. Con este compilador podemos escribir nuestras paginas en Scala y ejecutarlas en nuestro browser preferido. Entre las características más importantes podemos nombrar:

  • Soporte total de scala (hasta macros)
  • Muy buena interoperabilidad con javascript. 
  • Integración con Sbt
  • Puede utilizar la IDE que prefiera para programar en Scala
Dejo link: