Y más libros!!

Encontré otro link donde se pueden bajar más libros:
http://it-ebooks.info/

A leer!!

Más libros gratis!!

Querías leer? Te voy a dejar un link que vale oro, muchos libros gratis de informática, pero muchos...

Dejo el link:
http://bookdl.com

Libros Gratis

Como si uno no tuviera cosas para estudiar o leer!!

Quiero compartir este link en el que se pueden descargar libros de forma gratuita. Entre los temas de los libros esta Android, AngularJs, Windows Phone 8, Html 5, etc.

Dejo link:
http://theneodesign.com/latest-free-ebooks-for-developers/

Linux apesta

Me resulto muy interesante este vídeo que les quiero compartir. Les pido un favor no piensen que soy enemigo de Linux porque publico esto; ya maduramos un poco de autocritica no viene mal.

 

Elixir

José Valim decidió crear un lenguaje para aumentar la productividad en la plataforma Erlang y lo consiguió. El nombre de este lenguaje es Elixir

Elixir es lenguaje de programación de propósito general, concurrente; este lenguaje es funcional. Además esta construido sobre la máquina virtual de Erlang. Se trata de un lenguaje dinámico con una sintaxis flexible y apoyado en macros; que aprovecha las capacidades de Erlang para construir aplicaciones concurrentes y distribuidas, tolerables a fallos, con actualizaciones de código en caliente.

Elixir también soporta pattern matching, el polimorfismo a través de protocolos (similar a Clojure), alias y estructuras de datos asociativos (generalmente conocido como hashes en otros lenguajes de programación).

Por útimo, Elixir y Erlang comparten el mismo byte code. Esto significa que puede invocar código Erlang de Elixir (y viceversa) sin ningún tipo de transformación o impacto en el rendimiento. Esto permite a los desarrolladores mezclar la expresividad de Elixir con la robustez y el rendimiento de Erlang.

Veamos un ejemplo, es bueno comenzar con un "hola mundo" pero para hacerlo más interesante vamos a hacerlo dentro de un modulo:

defmodule Hello do
  IO.puts "Defining the function world"

  def world do
    IO.puts "Hello World"
  end

  IO.puts "Function world defined"
end


Hello.world


Los módulos son simplemente una forma lógica de organizar el código, no se debe confundir con una clase, ya que no tiene propiedades.


Este código retorna:


Defining the function world
Function world define

Hello World

Si queremos probar el ejemplo solo debemos guardar el ejemplo como Hello.ex y luego debemos compilar, para eso ejecutamos el relp de Elixir y compilamos de la siguiente manera:


Interactive Elixir
iex> c("Hello.ex")
[Hello]
iex> Hello.hello
Defining the function world
Function world define
Hello World
:ok

Elixir tiene varias características que lo hacen un muy buen lenguaje para programar, como por ejemplo tiene pattern matching, veamos un ejemplo:


def serve_drinks({ User, name, age }) when age < 21 do
  raise "No way #{name}!"
end

def serve_drinks({ User, name, age }) do
  # Code that serves drinks!
end

serve_drinks User.get("John")
#=> Raises "No way John!" if John is under 21

Otra característica interesante es que la documentación es muy importante para elixir. Por lo que provee mecanismos que facilitan documentar nuestro código, veamos un ejemplo:

defmodule MyModule do
  @moduledoc """
  Documentation for my module. With **formatting**.
  """

  @doc "Hello"
  def world do
    "World"
  end
end

Y como es de esperar, Elixir provee herramientas que facilitan el acceso a la documentación.


iex> h MyModule
# MyModule

Documentation for my module. With **formatting**.

Elixir es un lenguaje que nació para facilitar el desarrollo en la plataforma Erlang y vaya que lo logro!

Dejo link:
http://elixir-lang.org/

Manejar la concurrencia con Actores.

El modelo de actores que fue propuesto por primera vez por Carl Hewitt en 1973; es un modelo de concurrencia computacional que al igual que los hilos, trata de solucionar el problema de la concurrencia.

En el modelo de actores, cada objeto es un actor. Esta es una entidad que tiene una cola de mensajes o buzón y un comportamiento. Los mensajes pueden ser intercambiados entre los actores y se almacenan en el buzón. Al recibir un mensaje, el comportamiento del actor se ejecuta. El actor puede : enviar una serie de mensajes a otros actores, crear una serie de actores y asumir un nuevo comportamiento para el próximo mensaje.

La importancia en este modelo es que todas las comunicaciones se llevan a cabo de forma asincrónica. Esto implica que el remitente no espera a que un mensaje sea recibido en el momento que lo envío, solo sigue su ejecución.

Una segunda característica importante es que todas las comunicaciones se producen por medio de mensajes: no hay un estado compartido entre los actores. Si un actor desea obtener información sobre el estado interno de otro actor, se tendrá que utilizar mensajes para solicitar esta información. Esto permite a los actores controlar el acceso a su estado, evitando problemas.

Erlang es un lenguaje de programación concurrente y un sistema de ejecución que incluye una máquina virtual y bibliotecas. Fue diseñado en la compañía Ericsson para realizar aplicaciones distribuidas, tolerantes a fallos y de funcionamiento ininterrumpido. Originalmente, Erlang era un lenguaje propietario de Ericsson, pero fue cedido como software de código abierto en 1998. La implementación de Ericsson es, principalmente interpretada pero también incluye un compilador HiPE (sólo soportado en algunas plataformas).

Entre los mayores logros de la plataforma podemos destacar que el chat de facebook y la base documental CouchDB.

Sin dudas una cosa que hace muy especial de Erlang es como maneja la concurrencia. Erlang no maneja la concurrencia con hilos como nos tiene acostumbrado C, C++ o Java. Erlang soluciona la programación concurrente mediante el modelo de actores.

En Erlang los procesos o actores:

• Son rápidos de crear y destruir.
• El envío de mensajes entre procesos es muy rápido.
• Es fácil mantener un gran número de procesos.
• Son ligeros.
• Son independientes y no comparten memoria.
• Sólo un proceso tratará un mensaje pasado, en ningún caso pasará por otro proceso.

Parece complicado, pero no lo es. Con un ejemplo vamos a aclarar el tema. Supongamos que queremos hacer un actor saludador, pero no muy simpático; que salude solo a los conocidos; en erlang sería así:

-module(saludador).
-export([loop/0]).
loop() ->
receive
% Saluda a un conocido
"conocido" ->
io:format("Hola!! " ),
loop();
% Un desconocido, no lo saluda
_ ->
io:format(" ... " ),
loop()
end.

En la primera línea declaramos el modulo; luego importamos la función loop, con la cual definimos una función vacía e iteramos para siempre. Con receive recibimos un mensaje, es similar al swich, espera a recibir un mensaje y al recibir un mensaje ejecuta la estructura de código que corresponde al mensaje enviado y el “_” es como el default del swich en c, c++ o java.

Primero compilamos, para esto vamos a guardar nuestro saludador en el fichero saludador.erl y luego en la consola de Erlang escribimos:

1> c(saludador).
{ok,saludador}

Con spawn se puede generar un proceso, spawn nos devolverá el PID del proceso, que nos servirá para enviarle mensajes.

2> Pid = spawn(fun saludador:loop/0).
<0.38.0>

Ahora le vamos a mandar un mensaje:

4> Pid ! "conocido".
Hola!! "conocido"

5> Pid ! "Pepe".
... "Pepe"

Como era de esperar solo dice hola a los conocidos. Con el operador ! enviamos mensajes a un actor a partir de su Pid.

Éste es un pequeño ejemplo de manejo de concurrencia en erlang. La forma en que maneja la concurrencia Scala fue inspirada en Erlang.

Scala implementa el modelo de actores similar a Erlang, veamos un poco de código:

import scala.actors.Actor

class Saludador extends Actor  {

  

  def act() = {

        while (true) {

            receive {

                case "conocido" =>

                    println("Hola!")

                case _ =>

                    println("...")

            }

        }

    }

}

object ActorsTest extends App {

  val saludador = new Saludador

  saludador.start()

  

  saludador ! "otro"

  saludador ! "conocido"

}

Akka es un framework java que nos brinda este modelo en el lenguaje java. Permitiéndonos manejar la concurrencia de forma más simple como lo hace scala o erlang.

Veamos un ejemplo:

import akka.actor.Props;
import akka.actor.UntypedActor;
import akka.actor.ActorRef;

public class HelloWorld extends UntypedActor {

  @Override
  public void preStart() {
    // create the greeter actor
    final ActorRef greeter = getContext().actorOf(Props.create(Greeter.class), "greeter");
    // tell it to perform the greeting
    greeter.tell(Greeter.Msg.GREET, getSelf());
  }

  @Override
  public void onReceive(Object msg) {
    if (msg == Greeter.Msg.DONE) {
      // when the greeter is done, stop this actor and with it the application
      getContext().stop(getSelf());
    } else
      unhandled(msg);
  }
}

Como podemos ver en ejemplo podemos hacer un manejo de actores de forma remota. Akka es tolerable a fallos dado que fue concedido con tecnología Let it crash/Embrace failure. Akka es de código abierto y está disponible bajo la licencia Apache 2. A la vez está basado en scala y provee una Api para este lenguaje.

Akka tiene integración con Spring, soporta OSGI, se integra con Apache Camel y la última versión soporta Java 8. ¡Solo falta que cocine y lave la ropa!

Desarrollar aplicaciones concurrentes puede ser un dolor de cabeza. Por este motivo nació el modelo de actores, para simplificar el desarrollo concurrente.

Codebabes

Si no aprendes programación por iniciativa, hacelo por baboso...

CodeBabes es el sitio que enseña programación con profesoras desnudistas!!

CodeBabes un sitio web de aprendizaje online que ofrece cursos para diversas disciplinas informáticas, todos narrados por curvilíneas instructoras. El principal motivador en su metodología es que si logras superar un test y pasar a la siguiente lección, tu profesora te premiará desprendiéndose de una parte de sus ropas. Y así consecutivamente.

Dejo link:
https://codebabes.com/

Open Source explicado con lego!

Quiero compartir este video explicativo sobre open source:

Netbeans 8, con soporte para Java 8 y Html 5

Para que decir más Netbeans parece una IDE venida del futuro, antes que ningún otra IDE tiene las novedades, en su versión 8. Trae soporte para Java 8 y para HTML 5.

Lo podemos descargar en diferentes versiones, les dejo el cuadro:

	NetBeans IDE Download Bundles
Supported technologies*	Java SE	Java EE	C/C++	HTML5 & PHP	All
NetBeans Platform SDK
Java SE
Java FX
Java EE
Java ME
HTML5
Java Card™ 3 Connected
C/C++
Groovy
PHP
Bundled servers
GlassFish Server Open Source Edition 4.0
Apache Tomcat 8.0.3
	Free, 89 MB	Free, 191 MB	Free, 62 MB	Free, 63 MB	Free, 203 MB

Dejo link:
https://netbeans.org
http://www.infoq.com/news/2014/04/netbeans8

Functional Programming Principles in Scala

Otra vez coursera lanza el curso "Functional Programming Principles in Scala" para el que no lo hizo, lo recomiendo, muy bueno!!




Dejo link:
https://www.coursera.org/course/progfun

Desarrolla en Android con Scala con Scaloid

Al parecer se puede programar en Android con Scala gracias a Scaloid.

Scaloid es una biblioteca que simplifica el código de Android. Esto hace que el código sea fácil de entender y mantener gracias al lenguaje Scala.

Veamos un ejemplo en Java:

val button = new Button(context)
button.setText("Greet")
button.setOnClickListener(new OnClickListener() {
  def onClick(v: View) {
    Toast.makeText(context, "Hello!", Toast.LENGTH_SHORT).show()
  }
})
layout.addView(button);

Y ahora en Scala con Scaloid:

SButton("Greet", toast("Hello!"))

Y eso es todo!

Parece de cuento la verdad, lo voy a tener que probar...

Dejo el link:
https://github.com/pocorall/scaloid
http://blog.scaloid.org/2014/04/scaloid-33-is-released.html