domingo, 17 de septiembre de 2017

Elixir 1.5 fue liberado!

Elixir 1.5 trae muchas mejoras a la experiencia y calidad de vida del desarrollador. Es decir esta versión se centro que mejorar la interactividad con el desarrollador.

Entre las mejoras que tenemos podemos nombrar:

UTF-8 para atoms, nombres de funciones y variables, por ejemplo :

test "こんにちは世界" do
  assert :こんにちは世界
end

o

saudação = "Bom dia!"

Elixir 1.5 es más accesible a otros idiomas y comunidades. Los identificadores deben seguir siendo una secuencia de letras, seguida de dígitos y combinar marcas. Esto significa que los símbolos, como las notaciones matemáticas y emojis, no están permitidos en los identificadores.

IEx obtuvo muchas mejoras en la experiencia del desarrollador. En primer lugar, el sistema de autocompletado es ahora capaz de autocompletar variables y imports.

IEx también obtuvo nuevas funciones, como listar todas las funciones y macros en un módulo.

Por último, IEx también cuenta con un sistema de punto de interrupción para la depuración de código cuando se ejecuta en Erlang / OTP 20

Exception.blame/3 es una nueva función de Elixir que es capaz de adjuntar información de depuración a ciertas excepciones. Actualmente se utiliza para aumentar FunctionClauseErrors con un resumen de todas las cláusulas y qué partes de la cláusula coinciden y cuáles no.

Elixir v1.5 simplifica la forma en que los supervisores se definen y utilizan en Elixir. Elixir ahora permite especificaciones hijas, que especifican cómo se supervisará un proceso hijo, que se definirá en módulos.

Esta versión incluye muchas mejoras en funciones de calendario, como Date.range/2 y la posibilidad de convertir entre diferentes calendarios.

Estas son algunas mejoras que vienen en esta nueva versión.

Dejo link: https://elixir-lang.org/blog/2017/07/25/elixir-v1-5-0-released/

Blog de angular


Quiero recomendarles un excelente blog de angular y javascript de Todd Motto que es un Developer Expert de google. Este desarrollador abrió una empresa de cursos de angular "Ultimate Angular".

El blog esta muy completo como para tenerlo de referencia.

Dejo link: https://toddmotto.com

jueves, 14 de septiembre de 2017

Cómo utilizar el conector de BI con MongoDb

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

Come utilizar el conector de BI
Fecha: martes, 19 de septiembre
Hora: 16:00 CEST (GMT +2) | 9:00 CDT (GMT -6)

Hola Emanuelpeg,

Inscríbase en este seminario web y descubra cómo utilizar MongoDB como fuente de datos mediante el conector de BI en las plataformas analíticas y de BI basadas en SQL. También aprenderá cómo crear visualizaciones y paneles de control para extraer la información y el valor oculto de los datos multi-estructurados.
INSCRÍBASE AHORA

Este es el tercero de los cuatro seminarios web de la serie "Conceptos Avanzados", en los que se describen las características y funciones avanzadas de MongoDB. Le ayudarán a conocer MongoDB y los casos en los que resulta idónea esta solución.

Esperamos verle pronto.

Saludos cordiales,

El equipo de MongoDB
 
  Share on Twitter Share on Facebook Share on LinkedIn Share 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í.
 
Para ver la versión en línea haga clic aquí.

miércoles, 13 de septiembre de 2017

Java EE se mueve a la organización eclipse




Como habíamos dicho en otro post: https://emanuelpeg.blogspot.com.ar/2017/08/java-ee-bajo-una-organizacion-open.html

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

Bueno la Fundación Eclipse resultó seleccionada para albergar el proyecto y plataforma Java EE. La verdad que es una buenisima noticia.

Java EE en las manos de eclipse no creo que gane mayor agilidad pero sin duda va ser más abierto y comunitario.

Github de Java EE : https://github.com/javaee

Dejo link: https://blogs.oracle.com/theaquarium/opening-up-ee-update
http://middlewareblog.redhat.com/2017/09/12/java-ee-moves-to-eclipse/
https://mmilinkov.wordpress.com/2017/09/12/java-ee-moves-to-the-eclipse-foundation/

martes, 12 de septiembre de 2017

Blog sobre c++


Quiero recomendarles un blog sobre c++ para los que empiezan con el lenguaje.

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

domingo, 10 de septiembre de 2017

Empezando con Elixir 9


Composición

Ahora que sabemos cómo crear módulos y estructuras vamos a aprender cómo agregar la funcionalidad existente a ellos a través de la composición. Elixir nos proporciona una variedad de formas diferentes de interactuar con otros módulos.

alias

Nos permite alias nombres de módulo; utilizado con bastante frecuencia en código Elixir:

defmodule Sayings.Greetings do
  def basic(name), do: "Hi, #{name}"
end

defmodule Example do
  alias Sayings.Greetings

  def greeting(name), do: Greetings.basic(name)
end

# Without alias

defmodule Example do
  def greeting(name), do: Sayings.Greetings.basic(name)
end

Si hay un conflicto entre dos alias o simplemente deseamos alias a un nombre diferente por completo, podemos usar la opción: ":as"

defmodule Example do
  alias Sayings.Greetings, as: Hi

  def print_message(name), do: Hi.basic(name)
end

Incluso es posible alias múltiples módulos a la vez:

defmodule Example do
  alias Sayings.{Greetings, Farewells}
end

import

Si queremos importar funciones y macros en lugar de usar alias, podemos usar import/:

iex> last([1, 2, 3])
** (CompileError) iex:9: undefined function last/1
iex> import List
nil
iex> last([1, 2, 3])
3

Filtración

De forma predeterminada, todas las funciones y macros se importan, pero podemos filtrarlas mediante las opciones :only y :except.

Para importar funciones y macros específicas, debemos especificar los pares nombre de función y numero de parámetros a: only y :except. Comencemos importando sólo la función last/1 :

iex> import List, only: [last: 1]
iex> first([1, 2, 3])
** (CompileError) iex:13: undefined function first/1
iex> last([1, 2, 3])
3

Si importamos todo excepto last/1 e intentamos usar las mismas funciones que antes:

iex> import List, except: [last: 1]
nil
iex> first([1, 2, 3])
1
iex> last([1, 2, 3])
** (CompileError) iex:3: undefined function last/1

Hay dos átomos especiales, :functions y :macros, que importan sólo funciones y macros respectivamente:

import List, only: :functions
import List, only: :macros

require

Aunque se utiliza menos frecuentemente require/2 es importante. Requerir un módulo asegura que está compilado y cargado. Esto es muy útil cuando necesitamos acceder a las macros de un módulo:

defmodule Example do
  require SuperMacros

  SuperMacros.do_stuff
end

Si tratamos de llamar a una macro que aún no está cargada Elixir generará un error.

use

La macro "use" invoca una macro especial, llamada __using __/1, del módulo especificado. He aquí un ejemplo:

# lib/use_import_require/use_me.ex
defmodule UseImportRequire.UseMe do
  defmacro __using__(_) do
    quote do
      def use_test do
        IO.puts "use_test"
      end
    end
  end
end

y agregamos esta línea a UseImportRequire:

use UseImportRequire.UseMe

El uso de UseImportRequire.UseMe define una función use_test/0 mediante la invocación de la macro __using __/1.

Esto es todo lo que hace el uso. Sin embargo, es común que la macro __using__, a su vez, llame alias, require, o import. Esto a su vez creará alias o importaciones en el módulo de uso. Esto permite que el módulo que se utiliza para definir una política de cómo sus funciones y macros deben ser referenciados. Esto puede ser bastante flexible en que __using __/1 puede establecer referencias a otros módulos, especialmente submódulos.

El marco de Phoenix utiliza el use y __using __/1 para reducir la necesidad de alias repetitivas e import llamadas en módulos definidos por el usuario.

He aquí un ejemplo del módulo Ecto.Migration:

defmacro __using__(_) do
  quote location: :keep do
    import Ecto.Migration
    @disable_ddl_transaction false
    @before_compile Ecto.Migration
  end
end

La macro Ecto.Migration .__ using__/1 incluye una llamada de importación para que cuando utilice Ecto.Migration también importe Ecto.Migration. También configura una propiedad de módulo que asumimos que controla el comportamiento de Ecto.

Para recapitular: la macro de uso simplemente invoca la macro __using __/1 del módulo especificado. Para entender realmente qué es lo que necesita para leer la macro __using __/1.

Dejo link: https://elixirschool.com/en/lessons/basics/modules/

Empezando con Elixir 8

Estructuras

Una estructura puede verse como un mapa es decir como una estructura clave/valor. Una estructura debe definirse dentro de un módulo, del cual toma su nombre. Es común que una estructura sea la única cosa definida dentro de un módulo.

Para una estructura debemos utilizar la palabra clave defstruct y luego debemos definir los campos y los valores:

defmodule Example.User do
  defstruct name: "Sean", roles: []
end

Vamos a crear algunas estructuras:

iex> %Example.User{}
%Example.User{name: "Sean", roles: []}

iex> %Example.User{name: "Steve"}
%Example.User{name: "Steve", roles: []}

iex> %Example.User{name: "Steve", roles: [:admin, :owner]}
%Example.User{name: "Steve", roles: [:admin, :owner]}

Podemos actualizar nuestra estructura como si fuera un mapa:

iex> steve = %Example.User{name: "Steve", roles: [:admin, :owner]}
%Example.User{name: "Steve", roles: [:admin, :owner]}
iex> sean = %{steve | name: "Sean"}
%Example.User{name: "Sean", roles: [:admin, :owner]}

Lo más importante, puede combinar estructuras con mapas:

iex> %{name: "Sean"} = sean
%Example.User{name: "Sean", roles: [:admin, :owner]}

Dejo link: https://elixirschool.com/en/lessons/basics/modules/

Empezando con Elixir 7



Modulos

Todos sabemos que tener todas las funciones en un mismo archivo sin nin gun scope o orden es muy propicio al caos general. Por esta razón Elixir nos brinda el concepto de modulo.

Un Modulo nos permite organizar nuestras funciones dentro de un espacio de nombre. Además de agrupar las funciones, nos permiten definir funciones nombradas y privadas.

Definamos un modulo de ejemplo:

defmodule Example do
  def greeting(name) do
    "Hello #{name}."
  end
end

iex> Example.greeting "Sean"
"Hello Sean."

Es posible anidar módulos en Elixir, lo que le permite ampliar el espacio de nombres de su funcionalidad:

defmodule Example.Greetings do
  def morning(name) do
    "Good morning #{name}."
  end

  def evening(name) do
    "Good night #{name}."
  end
end

iex> Example.Greetings.morning "Sean"
"Good morning Sean."

Atributos de los Modulos

Los atributos de los modulos pueden ser vistos como constantes. Veamos un ejemplo:

 defmodule Example do
  @greeting "Hello"

  def greeting(name) do
    ~s(#{@greeting} #{name}.)
  end
end

Es importante observar que hay atributos reservados en Elixir. Los tres más comunes son:

  • moduledoc - Documentos del módulo actual.
  • doc - Documentación para funciones y macros.
  • behaviour - Usado en OTP o un comportamiento definido por el usuario.







Top 5 de nuevas características de Entity Framework Core 1.0


.net core viene tomando cada vez más relevancia en el mundo del desarrollo y como era de pensar cada vez se nutre más de sus frameworks por esta razón vamos a analizar 5 características de Entity Framework Core 1.0

Entity Framework Core es un mapeador relacional de objetos (ORM) que permite a los desarrolladores de .NET trabajar con una base de datos utilizando objetos .NET. Elimina la necesidad de la mayor parte del código de acceso a datos que los desarrolladores normalmente necesitan escribir. Hablando mal y pronto un hibernate de .net y microsoft

1. Cross plataforma, de igual manera que .net core su mayor fortaleza es que corre en cualquier plataforma como Windows, Mac, y mi amado Linux. A la vez permite conectarse a diferentes bases de datos como SQL Server, SQLite, Postgres, MySQL y pronto va estar desarrollo la conexión a bases nosql

2.Liviano, modular y extensible: Entity Framework Core se ha descompuesto en paquetes / componentes manejables más pequeños, por lo tanto podemos utilizar los que sean útiles para el proyecto. Estos componentes también se pueden ampliar para agregar funcionalidad adicional.

3.In-Memory Provider:  Se puede utilizar un almacén de datos en memoria, puede ejercitar su código de acceso de datos contra una base de datos real que sólo existe en la memoria. Facilitando las pruebas.

4.Propiedades ocultas o Shadow: Podemos modificar campos que solo existen en la base que se denominan shadow:

public class CoursesContext : DbContext
{
    public DbSet<Course> Courses { get; set; }
    public DbSet<Student> Students { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Course>()
            .Property<DateTimeOffset>("LastUpdated");
    }
}

context.Entry(myCourse).Property("LastUpdated").CurrentValue = DateTimeOffset.Now;

5.Evaluación mixta cliente/servidor: La evaluación mixta cliente/servidor permite que las consultas contengan una lógica que se pueda evaluar en el cliente.

Por ejemplo tenemos un método así:

public static string AddTitle(string strFirstName)
{
    if (!strFirstName.ToLower().StartsWith("Mr"))
    {
        strFirstName = string.Concat("Mr.", strFirstName);
    }
    return strFirstName;
}

Podemos hacer la siguiente consulta:

var emp = context.Employee
    .Where(emp => emp.Gender == "M")
    .Select(employee => new
    {
        FirstName = AddTitle(employee.FirstName),
        LastName  = employee.LastName
    })
    .ToList();

Donde llamamos a la función AddTitle que se ejecutará en memoria.

Que piensan? es acertado este Top 5?

Dejo link: http://www.csharpstar.com/new-features-of-entity-framework-core/



jueves, 7 de septiembre de 2017

Python supera a R, se convierte en el lenguaje más utilizado para procesamiento de datos en ciencia y Machine Learning


Python supera a R, se convierte en el lenguaje más utilizado para procesamiento de datos en ciencia y Machine Learning (me quedo largo el titulo). Es así, según kdnuggets que dice algo así:

"Python no "tragó" R, pero los resultados, basados en 954 votantes, muestran que en 2017 el ecosistema de Python superó a R como la plataforma líder de Analytics, Data Science, Machine Learning.

Mientras que en 2016 Python estaba en segundo lugar ("Mainly Python" tenía 34% de participación vs 42% para "Mainly R"), en 2017 Python tiene 41% vs 36% para R.

La proporción de lectores de KDnuggets que usaron tanto R como Python de manera significativa también aumentó del 8,5% al 12% en 2017, mientras que la participación que utilizó principalmente otras herramientas cayó de 16% a 11%."

Es decir que Python se afianza como lenguaje para las ciencias y Machine Learning, veamos unos gráficos que muestran su evolución:


El futuro parece brillante para los usuarios de Python, pero R y otras plataformas se mantendrán dado que ya ganaron mucho terreno.

Dejo link: http://www.kdnuggets.com/2017/08/python-overtakes-r-leader-analytics-data-science.html

martes, 5 de septiembre de 2017

Linux supera el 3% de cuota de mercado por primera vez en el escritorio





Según las estadísticas de NetMarketShare para el mes de agosto de 2017, Linux supera el 3% de cuota de mercado por primera vez en el escritorio.

Si bien 3% suena a poco es un gran avance y lo mejor es que la cosa viene mejorando. En lo personal veo a casa vez más gente usando linux.

El crecimiento que ha ido subiendo progresivamente desde junio de 2016, cuando alcanzó el 2%, ha dado un salto bastante significativo este agosto. NetMarketShare sitúa a Linux con un 3,37% de la cuota de mercado de sistemas operativos de escritorio.

Según mi parecer debemos agradecerlo a Ubuntu y Mint, que han llevado el escritorio más cerca del usuario común.

Dejo link: https://www.netmarketshare.com/operating-system-market-share.aspx?qprid=9&qpcustomb=0&qpcd=1&qpct=2

domingo, 3 de septiembre de 2017

Que es Apache Kafka?

Apache Kafka se ha vuelto cada vez más popular, pero porque utilizar kafka?

Apache Kafka es generalmente utilizado en arquitecturas real-time que utilizan Stream de datos, para proporcionar análisis en tiempo real. Kafka es un sistema de mensajería publicación-suscripción rápido, escalable, duradero y tolerante a fallos.

Kafka se usa en casos de uso donde JMS, RabbitMQ y AMQP no pueden ni siquiera ser considerados debido al volumen y a la capacidad de respuesta. Kafka tiene mayor rendimiento, fiabilidad y características de replicación, lo que hace que sea aplicable para cosas como el seguimiento de las llamadas de servicio (rastrea cada llamada) o el seguimiento de los datos de sensores IoT donde una MOM tradicional puede no ser considerada.

Kafka puede trabajar con Flume / Flafka, Spark Streaming, Storm, HBase, Flink y Spark para la consumo, análisis y procesamiento en tiempo real de los datos de transmisión. Kafka es un flujo de datos utilizado para alimentar bases que utiliza Hadoop para análisis BigData. Además, Kafka Streaming (un subproyecto) se puede utilizar para análisis en tiempo real.

Kafka se utiliza para procesamiento de secuencias, seguimiento de actividades de sitios web, recopilación y monitoreo de métricas, agregación de registros, análisis en tiempo real, CEP, carga de datos en Spark, administración de datos en Hadoop, CQRS, computación en memoria (microservicios).

Kafka es una plataforma de streaming distribuida que se utiliza para sistemas stream publicar-suscribirse. Kafka se utiliza para el almacenamiento tolerante a fallos. Kafka replica particiones de registro de temas en varios servidores. Kafka está diseñado para permitir que tus aplicaciones procesen registros a medida que ocurren. Kafka es rápido y utiliza IO de forma eficiente mediante el batching y la compresión de registros. Kafka se utiliza para desacoplar flujos de datos. Kafka se utiliza para transmitir datos en lagos de datos, aplicaciones y sistemas de análisis de flujo en tiempo real.

Y para colmo es compatible para varios lenguajes como C#, Java, C, Python, Ruby (entre otros)...

Kafka permite construir en tiempo real de flujo de tuberías de datos. Kafka habilita micro-servicios en memoria (es decir actores, Akka, Baratine.io, QBit, reactores, reactivos, Vert.x, RxJava, Spring Reactor). Kafka le permite crear aplicaciones de streaming en tiempo real que reaccionan a los flujos para hacer análisis de datos en tiempo real, transformar, reaccionar, agregar, unir flujos de datos en tiempo real y realizar procesamiento de eventos complejos (CEP).

Puede utilizar Kafka para ayudar en la recopilación de métricas / KPIs, agregando estadísticas de muchas fuentes e implementando la generación de eventos. Puede utilizarlo con microservices (en memoria) y sistemas de actor para implementar servicios en memoria (log de confirmación externa para sistemas distribuidos).

Puede utilizar Kafka para replicar datos entre nodos, volver a sincronizar para nodos y restaurar estado. Aunque Kafka se utiliza principalmente para el análisis de datos en tiempo real y el procesamiento de secuencias, también puede utilizarse para la agregación de registros, mensajería, seguimiento de clics, pistas de auditoría y mucho más.

En un mundo donde la ciencia de los datos y el análisis es cada vez mas utilizado, la captura de datos para alimentar las bases de datos y sistemas de análisis en tiempo real también es un gran problema. Y aqu{i es donde Kafka se vuelve muy relevante.

Dejo link: https://dzone.com/articles/what-is-kafka?edition=316422&utm_source=Zone%20Newsletter&utm_medium=email&utm_campaign=big%20data%202017-08-17
https://kafka.apache.org/

jueves, 31 de agosto de 2017

7 lenguajes que se utilizan en inteligencia artificial


Leí un articulo por demás interesante sobre que lenguajes se utilizan en el desarrollo de sistemas inteligentes, es decir en el desarrollo de inteligencia artificial.

Los 7 lenguajes son:

  1. Python
  2. C++
  3. Lisp
  4. Java
  5. Prolog
  6. Javascript
  7. Haskell

Personalmente pienso que es bastante raro pero es explicable.

Python tiene la ventaja de ser fácil de utilizar por lo que los investigadores lo utilizan mucho.
C++ se utiliza para programar software que necesita alta performance como la ia.
Lisp, es el lenguaje de los matemáticos.
Java, no se :(
Prolog, es el lenguaje concebido para programar sistemas inteligentes
Javascript, ni idea
Y Haskell similar a lisp, es muy fácil de utilizar por matemáticos.

Otra cosa que me llama la atención es la cantidad de lenguajes funcionales: Lisp y Haskell.

Dejo link: http://www.rankred.com/best-artificial-intelligence-programming-language/

domingo, 27 de agosto de 2017

Empezando con Elixir 6


Funciones

En Elixir y muchos lenguajes funcionales, las funciones son ciudadanos de primera clase.

Funciones Anónimas

Tal como su nombre lo indica, una función anónima no tiene nombre. Como vimos en la lección de Enum, éstos se pasan con frecuencia a otras funciones. Para definir una función anónima en Elixir necesitamos las palabras clave fn y end. Dentro de éstos podemos definir cualquier número de parámetros y cuerpos funcionales separados por ->

iex> sum = fn (a, b) -> a + b end
iex> sum.(2, 3)
5

El operador &

El uso de funciones anónimas es una práctica común en Elixir hay una forma abreviada de hacerlo:

iex> sum = &(&1 + &2)
iex> sum.(2, 3)
5

Como probablemente ya se supone, en la versión abreviada nuestros parámetros están disponibles para nosotros como & 1, & 2, & 3, y así sucesivamente.

Pattern Matching

Pattern matching no esta limitado solo a variables sino que tambien se pueden utilizar en funciones.

Se pueden utilizar pattern matching con el primer conjunto de parámetros que coinciden e invoca el cuerpo correspondiente:

iex> handle_result = fn
...>   {:ok, result} -> IO.puts "Handling result..."
...>   {:error} -> IO.puts "An error has occurred!"
...> end

iex> some_result = 1
iex> handle_result.({:ok, some_result})
Handling result...

iex> handle_result.({:error})

An error has occurred!

Funciones con nombre

Podemos definir funciones con nombre utilizando la palabra clave def. Las funciones definidas dentro de un modulo pueden ser accedidas por otros módulos:

defmodule Greeter do
  def hello(name) do
    "Hello, " <> name
  end
end

iex> Greeter.hello("Sean")
"Hello, Sean"

Si queremos definir una función en una linea podemos usar do:

defmodule Greeter do
  def hello(name), do: "Hello, " <> name
end

Y podemos utilizar pattern matching:

defmodule Length do
  def of([]), do: 0
  def of([_ | tail]), do: 1 + of(tail)
end

iex> Length.of []
0
iex> Length.of [1, 2, 3]
3

Funciones con nombre y número de argumentos

Como el lenguaje es de tipado débil, la firma de la función esta dada por el nombre de la función y la cantidad de parámetros. Es decir las funciones aceptan sobre carga y esta dada por el numero de parametros:

defmodule Greeter2 do
  def hello(), do: "Hello, anonymous person!"   # hello/0
  def hello(name), do: "Hello, " <> name        # hello/1
  def hello(name1, name2), do: "Hello, #{name1} and #{name2}"
                                                # hello/2

end

A diferencia de otros lenguajes, la firma de una función esta dada por el nombre y el numero de parámetros.

Funciones privadas

Una función privada solo se puede llamar dentro del modulo y se define con  defp :

defmodule Greeter do
  def hello(name), do: phrase <> name
  defp phrase, do: "Hello, "
end

iex> Greeter.hello("Sean")
"Hello, Sean"

iex> Greeter.phrase
** (UndefinedFunctionError) undefined function: Greeter.phrase/0
    Greeter.phrase()

Guards

En el ejemplo siguiente tenemos dos funciones con la misma firma, nos basamos en guards para determinar qué utilizar en función del tipo del argumento:

defmodule Greeter do
  def hello(names) when is_list(names) do
    names
    |> Enum.join(", ")
    |> hello
  end

  def hello(name) when is_binary(name) do
    phrase() <> name
  end

  defp phrase, do: "Hello, "
end

iex> Greeter.hello ["Sean", "Steve"]
"Hello, Sean, Steve"

Argumentos por defecto

Se pueden utilizar argumentos por defecto:

defmodule Greeter do
  def hello(name, language_code \\ "en") do
    phrase(language_code) <> name
  end

  defp phrase("en"), do: "Hello, "
  defp phrase("es"), do: "Hola, "
end

iex> Greeter.hello("Sean", "en")
"Hello, Sean"

iex> Greeter.hello("Sean")
"Hello, Sean"

iex> Greeter.hello("Sean", "es")
"Hola, Sean"

Cuando combinamos nuestro ejemplo de guard con argumentos predeterminados, nos topamos con un problema. Veamos cómo podría verse:

defmodule Greeter do
  def hello(names, language_code \\ "en") when is_list(names) do
    names
    |> Enum.join(", ")
    |> hello(language_code)
  end

  def hello(name, language_code \\ "en") when is_binary(name) do
    phrase(language_code) <> name
  end

  defp phrase("en"), do: "Hello, "
  defp phrase("es"), do: "Hola, "
end

** (CompileError) def hello/2 has default values and multiple clauses, define a function head with the defaults

Elixir no le gusta los argumentos por defecto en múltiples funciones de coincidencia, puede ser confuso. Para manejar esto agregamos una cabeza de función con nuestros argumentos por defecto:

defmodule Greeter do
  def hello(names, language_code \\ "en")
  def hello(names, language_code) when is_list(names) do
    names
    |> Enum.join(", ")
    |> hello(language_code)
  end

  def hello(name, language_code) when is_binary(name) do
    phrase(language_code) <> name
  end

  defp phrase("en"), do: "Hello, "
  defp phrase("es"), do: "Hola, "
end

iex> Greeter.hello ["Sean", "Steve"]
"Hello, Sean, Steve"

iex> Greeter.hello ["Sean", "Steve"], "es"
"Hola, Sean, Steve"

Dejo link: https://elixirschool.com/en/lessons/basics/functions/

miércoles, 23 de agosto de 2017

Datacamp, aprendiendo a manipular datos


Data + camp, es decir un campamento para datos, es realidad no, datacamp es un sitio donde podemos hacer toda clase de cursos relacionados al procesamiento de datos.

Se pueden hacer toda clase de cursos de manipulación de datos pero se usa sobre todo Python y R. También hay uno sobre Apache spark

Sin más que lo disfruten!!

Dejo link: https://www.datacamp.com/

Comienza la inscripción de los cursos Gugler


Quiero invitarlos a los cursos gugler, que se dictan de forma remota o a distancia o presencial, para mayor información: 




martes, 22 de agosto de 2017

Ceylon es de la fundación eclipse

Al parecer el lenguaje Ceylon se ha movido a la fundación eclipse. Por medio de un post lo han publicado Stéphane Épardaud y Gavin King, nos han dicho:

"Red Hat es sinónimo de Open source, calidad y confianza a la comunidad. Pero también hemos tenido un temor creciente de que la fuerte asociación con una sola compañía pueda haber frenado nuestra comunidad. Siempre hemos visto este proyecto como un "terreno neutral", no como un vehículo para los objetivos de negocio de una empresa, pero no estamos seguros si el proyecto es percibido de esa manera desde fuera."

Por lo tanto este proyecto va estar bajo la fundación eclipse. Esto no se si es bueno o malo, en lo que coincido es que le va dar una briza más open sources al proyecto y espero que siga creciendo.

Dejo links:
https://ceylon-lang.org/blog/2017/08/21/eclipse-ceylon/
https://projects.eclipse.org/proposals/eclipse-ceylon

sábado, 19 de agosto de 2017

Como va el resumen de Scala for the Impatient? 2

Siguiendo con el post "Como va el resumen de Scala for the Impatient?"

Puff vamos a un ritmo sostenido...

Dejo los links:
http://emanuelpeg.blogspot.com.ar/2017/03/un-resumen-de-scala-for-impatient-parte_26.html
http://emanuelpeg.blogspot.com.ar/2017/04/un-resumen-de-scala-for-impatient-parte.html
http://emanuelpeg.blogspot.com.ar/2017/04/un-resumen-de-scala-for-impatient-parte_15.html
http://emanuelpeg.blogspot.com.ar/2017/04/un-resumen-de-scala-for-impatient-parte_30.html
http://emanuelpeg.blogspot.com.ar/2017/05/un-resumen-de-scala-for-impatient-parte.html
http://emanuelpeg.blogspot.com.ar/2017/05/un-resumen-de-scala-for-impatient-parte_28.html
http://emanuelpeg.blogspot.com.ar/2017/06/un-resumen-de-scala-for-impatient-parte.html
http://emanuelpeg.blogspot.com.ar/2017/06/un-resumen-de-scala-for-impatient-parte_20.html
http://emanuelpeg.blogspot.com.ar/2017/06/un-resumen-de-scala-for-impatient-parte_61.html
http://emanuelpeg.blogspot.com.ar/2017/06/un-resumen-de-scala-for-impatient-parte_25.html
http://emanuelpeg.blogspot.com.ar/2017/07/un-resumen-de-scala-for-impatient-parte.html
http://emanuelpeg.blogspot.com.ar/2017/07/un-resumen-de-scala-for-impatient-parte_24.html
http://emanuelpeg.blogspot.com.ar/2017/08/un-resumen-de-scala-for-impatient-parte.html
http://emanuelpeg.blogspot.com.ar/2017/08/un-resumen-de-scala-for-impatient-parte_6.html
http://emanuelpeg.blogspot.com.ar/2017/08/un-resumen-de-scala-for-impatient-parte_31.html
http://emanuelpeg.blogspot.com.ar/2017/08/un-resumen-de-scala-for-impatient-parte_13.html
http://emanuelpeg.blogspot.com.ar/2017/08/un-resumen-de-scala-for-impatient-parte_19.html

Un resumen de Scala for the Impatient, parte 30

Traits con implementaciones concretas. 

En scala, los métodos de los Trais pueden tener implementaciones. Por ejemplo:

trait ConsoleLogger {
    def log(msg: String) { println(msg) }
}

ConsoleLogger provee una implementación, en este caso imprime el log en consola.

Si deseamos utilizar este trait:

class SavingsAccount extends Account with ConsoleLogger {
    def withdraw(amount: Double) {
        if (amount > balance) log("Insufficient funds")
            else balance -= amount
    }

}

Como se puede ver SavingsAccount es una clase concreta y utiliza el método por defecto de ConsoleLogger. En Java 8, también se puede realizar esto dado que se agregaron los métodos por defecto en las interfaces. Pero en scala una interfaz puede tener estado cosa que no se puede hacer en java.

En scala (y también en otros lenguajes que permiten esto) decimos que la función de ConsoleLog  es “mixed in” con la clase SavingsAccount.

Objetos con Trait

Se puede agregar un Trait con una implementación determinada a un objeto cuando se lo instancia. Veamos un ejemplo:

abstract class SavingsAccount extends Account with Logger {
    def withdraw(amount: Double) {
        if (amount > balance) log("Insufficient funds")
        else …
    }
...
}

Esta clase es abstracta no tiene implementación para el método log por lo tanto o no podríamos instanciarla o (en java por ejemplo) podemos implementar esto en una clase anónima pero en scala tenemos otra opción podemos agregar una interfaz que implemente este método con la palabra with :

val acct = new SavingsAccount with ConsoleLogger

Por supuesto podemos llamar a otra instancia con diferente traits:

val acct2 = new SavingsAccount with FileLogger

Traits en capas

Puede agregar, a una clase o a un objeto, múltiples rasgos que se invocan entre sí a partir de la última llamada. Esto es útil cuando se necesita transformar un valor en etapas.

Por ejemplo:

trait TimestampLogger extends ConsoleLogger {
    override def log(msg: String) {
        super.log(s"${java.time.Instant.now()} $msg")
   }
}

Supongamos que queremos acotar el mensaje:

trait ShortLogger extends ConsoleLogger {
    override def log(msg: String) {
        super.log(if (msg.length <= 15) msg else s"${msg.substring(0, 12)}...")
    }
}

Como puede ver cada método log es modificado en las traits . La expresión super.log no tiene el mismo significado que en las clases. En los traits la expresión super.log no llama al método del padre sino que importa el orden con que se han agregado. Veamos 2 ejemplos:

val acct1 = new SavingsAccount with TimestampLogger with ShortLogger
val acct2 = new SavingsAccount with ShortLogger with TimestampLogger

Si utilizamos acct1 el log sera:

Sun Feb 06 17:45:45 ICT 2011 Insufficient...

Como podemos ver primero recorta el texto y luego agrega la fecha y si utilizamos acct2 :

Sun Feb 06 1...

Si utilizamos acct2 primero agrega la fecha y luego recorta el texto, con lo que no nos imprime ni siquiera la fecha completa.

Note que se puede indicar con super[ConsoleLog].log(...) de que padre vamos a llamar a este método.

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 #.