Haciendo un proyecto con scalatra

Scalatra es el Sinatra de scala.

Para el que no conoce Sinatra es un framework que permite hacer paginas web con las menores configuraciones y desarrollo posible. Trata de acelerar el desarrollo manteniendo un modelo simple y convención antes de configuración.  Y el mismo espíritu tiene Scalatra.

Vamos hacer un proyecto con sbt.

Vamos a la consola y hacemos:

sbt new scalatra/scalatra.g8

Luego nos va pedir un montón de datos, pero es fácil saber a que se refiere dado que presenta unos ejemplos.

Y con eso ya estamos, podemos ejecutar esto con el comando :

sbt jetty:start

Y podemos chequearlo en la url: http://localhost:8080/

Como funciona?

La clase MyScalatraServlet capta el método get / y responde con la vista.

import org.scalatra._

class MyScalatraServlet extends ScalatraServlet {

  get("/") {
    views.html.hello()
  }

}

Dejo link: http://scalatra.org/

¿Cuál es la diferencia entre SQL, NoSQL y NewSQL?

Me llego este mail de la gente de VoltDB, sobre un paper que trata sobre las diferencias entre SQL, NoSQL y NewSQL. Y como es costumbre quiero compartirlo con ustedes :

Hi Emanuel, Database technologies have come a long way since the 1980's. First there was SQL. Then along came NoSQL. And over the last decade, we’ve seen the emergence of NewSQL. Each database offers their own unique benefits, but are you aware of their drawbacks? In this white paper, we compare the differences between SQL vs. NoSQL vs. NewSQL databases and explore topics, including: The basics of NoSQL The promise of NewSQL 4 use cases where NoSQL databases fall short And more VoltDB 209 Burlington Rd. #203 MA Bedford You received this email because you are subscribed to emails from VoltDB Update your email preferences to choose the types of emails you receive. Unsubscribe from all future emails

Ejemplo con Java y Spark

Vamos hacer un pequeño ejemplo, una aplicación Java que utilice Spark para contar palabras. La aplicación calculara cuantas veces aparece una palabra en un archivo de texto.

Para hacer esto vamos a utilizar eclipse y maven.

Primero creamos un proyecto simple de maven, para lo cual podemos utilizar la consola, con el siguiente comando:

mvn archetype:generate
-DarchetypeGroupId=org.apache.maven.archetypes
-DarchetypeArtifactId=maven-archetype-quickstart
-DarchetypeVersion=RELEASE
-DgroupId=org.miOrganizacion
-DartifactId=nombreDelProyecto

o con eclipse, vamos a File -> New -> Project -> Maven -> Maven Project y luego elegimos es arquetipo "maven-archetype-quickstart" y luego completamos los campos groupId y artifactId. Y listo!

Ahora vamos agregar spark en las dependencias en el pom.xml :

  <dependency>
<groupId>org.apache.spark</groupId>
<artifactId>spark-core_2.11</artifactId>
<version>2.2.1</version>
</dependency>

Y vamos a indicarle que utilizaremos java 8 con la siguiente lineas :

<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>

El pom.xml queda de la siguiente manera:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>

<groupId>com.hexacta</groupId>
<artifactId>testSpark</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>

<name>testSpark</name>
<url>http://maven.apache.org</url>

<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>

<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>

<dependencies>

<dependency>
<groupId>org.apache.spark</groupId>
<artifactId>spark-core_2.11</artifactId>
<version>2.2.1</version>
</dependency>


<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>


</dependencies>
</project>

Y ahora, a programa!!.

Vamos hacer el ejemplo de contar palabras de un archivo de texto. Para lo cual haremos un objeto llamado "App.java" : 

package com.hexacta.testSpark;

import java.util.Arrays;

import org.apache.spark.api.java.JavaPairRDD;

import org.apache.spark.api.java.JavaSparkContext;

import org.apache.spark.api.java.JavaRDD;

import org.apache.spark.SparkConf;

import scala.Tuple2;

public class App {

public static void main(String[] args) {

// Create a SparkContext to initialize

SparkConf conf = new SparkConf().setMaster("local").setAppName("Word Count");

// Create a Java version of the Spark Context

JavaSparkContext sc = new JavaSparkContext(conf);

// Load the text into a Spark RDD, which is a distributed representation of each

// line of text

JavaRDD<String> textFile = sc.textFile("/java/spark/artists.csv");

JavaPairRDD<String, Integer> counts = textFile

                                .flatMap(s -> Arrays.asList(s.split("[ ,]")).iterator())

.mapToPair(word -> new Tuple2<>(word, 1)).reduceByKey((a, b) -> a + b);

counts.foreach(p -> System.out.println(p));

System.out.println("Total words: " + counts.count());

counts.saveAsTextFile("/java/spark/artistsCount.txt");

}

}

Dejo el repo git :
https://github.com/emanuelpeg/client-java-spark

Ejemplo con Scala y Spark

Vamos hacer un pequeño ejemplo, una aplicación Scala que utilice Spark para contar palabras. La aplicación calculara cuantas veces aparece una palabra en un archivo de texto.

Para hacer esto vamos a utilizar Intellij Idea. Primero vamos a bajar intellij idea community edition porque somos muy pobres.

Luego instalamos el plugin de Scala. Eso lo hacemos yendo a file->settings->plugins y ahí instalamos  el plugin de scala :

Luego debemos hacer un nuevo proyecto, vamos a elegir un proyecto sbt :

Luego agregamos esta dependencia en el archivo build.sbt :

libraryDependencies ++= {
  val sparkVer = "2.1.0"
  Seq(
    "org.apache.spark" %% "spark-core" % sparkVer
  )
}

Quedando de la siguiente manera :

name := "cliente-spark-scala"

version := "0.1"

scalaVersion := "2.11.0"

libraryDependencies ++= {
  val sparkVer = "2.1.0"
  Seq(
    "org.apache.spark" %% "spark-core" % sparkVer
  )
}

Luego de cambiar este archivo el IDE nos preguntará si importa las librerías o siempre importa las librerías. En este caso, elegimos cualquiera de los dos :

Y ahora, a programa!!.

Vamos hacer el ejemplo de contar palabras de un archivo de texto. Para lo cual haremos un objeto llamado "ScalaExample" :

object ScalaExample {

  import org.apache.spark.{SparkConf, SparkContext}

  def main(args: Array[String]): Unit = {
    //Create a SparkContext to initialize Spark
    val conf = new SparkConf()
    conf.setMaster("local")
    conf.setAppName("Word Count")
    val sc = new SparkContext(conf)

    // Load the text into a Spark RDD, which is a distributed representation of each line of text
    val textFile = sc.textFile("/java/spark/customers.txt")

    //word count
    val counts = textFile.flatMap(line => line.split(" "))
      .map(word => (word, 1))
      .reduceByKey(_ + _)

    counts.foreach(println)
    System.out.println("Total words: " + counts.count());
   // counts.saveAsTextFile("/java/spark/customersCount.txt");
  }

}

Dejo el repo git : 

https://github.com/emanuelpeg/exampleSparkScala

Cursos Gugler

Quiero recomendarles los siguientes cursos:

Crystal v0.26.0 fue liberado !!

Crystal es un lenguaje que tiene muchísimo futuro y en mi opinión es el lenguaje orientado a objeto de tipado estático mejor diseñado.

Es simple y la inferencia de tipos lo hace fácil de usar y al ser de tipado estático es muy rápido. 

Esta es su versión 0.26.0 y sigue creciendo. 

Lo único que a mi modo de ver las cosas debería hacer es correr en una plataforma donde pueda reutilizar frameworks como dot net core o java. Eso le daría una popularidad increíble.

Sin más espero que siga creciendo este gran lenguaje.

Dejo link:
https://crystal-lang.org/
https://github.com/crystal-lang/crystal/blob/master/CHANGELOG.md

5 cursos gratuitos de estructura de datos y algoritmos en Java y C

Si queremos aprender una tecnología nueva lo mejor es empezar por un libro o un curso y luego ir a tutoriales de internet. Saltar de tutorial en tutorial, nos da el conocimiento pero nos falta el orden. Con un curso o un libro aprendemos ordenadamente, como debe ser.

Por lo tanto dejo 5 cursos gratuitos de estructura de datos y algoritmos en Java y C :

• Data Structures & Algorithms with Java - Interview !!
• Data Structures Concepts in C
• Algorithms and Data Structures - Part 1
• Algorithms and Data Structures - Part 2
• Data Structure in Java

Data Science and Cognitive Computing Courses

Quiero compartir la siguiente página que permite hacer cursos de machine learning, Apache Spark, SQL, Python, R, Data science, Reactive, Scala, Big Data, etc...

Y todos de forma gratuita!

Dejo link: https://cognitiveclass.ai

Procesamiento de lenguaje natural con NLTK

NLTK es una plataforma líder para construir programas en Python para trabajar con datos de lenguaje natural.

Proporciona interfaces fáciles de usar a más de 50 recursos corporales y léxicos como WordNet, junto con un conjunto de bibliotecas de procesamiento de texto para clasificación, tokenización, derivación, etiquetado, análisis y razonamiento semántico, wrappers para bibliotecas de PNL.

NLTK es adecuado para lingüistas, ingenieros, estudiantes, educadores, investigadores y usuarios de la industria por igual. NLTK está disponible para Windows, Mac OS X y Linux. Lo mejor de todo es que NLTK es un proyecto gratuito, de código abierto, impulsado por la comunidad.

NLTK ha sido llamado "una herramienta maravillosa para enseñar y trabajar en lingüística computacional usando Python" y "una biblioteca increíble para jugar con el lenguaje natural".

Veamos unos ejemplos de lo que podemos hacer con nltk:

Tokenizar y etiquetar un texto:

>>> import nltk
>>> sentence = """At eight o'clock on Thursday morning
... Arthur didn't feel very good."""
>>> tokens = nltk.word_tokenize(sentence)
>>> tokens
['At', 'eight', "o'clock", 'on', 'Thursday', 'morning',
'Arthur', 'did', "n't", 'feel', 'very', 'good', '.']
>>> tagged = nltk.pos_tag(tokens)
>>> tagged[0:6]
[('At', 'IN'), ('eight', 'CD'), ("o'clock", 'JJ'), ('on', 'IN'),
('Thursday', 'NNP'), ('morning', 'NN')]

Identificar entidades:

>>> entities = nltk.chunk.ne_chunk(tagged)

>>> entities

Tree('S', [('At', 'IN'), ('eight', 'CD'), ("o'clock", 'JJ'),

           ('on', 'IN'), ('Thursday', 'NNP'), ('morning', 'NN'),

       Tree('PERSON', [('Arthur', 'NNP')]),

           ('did', 'VBD'), ("n't", 'RB'), ('feel', 'VB'),

           ('very', 'RB'), ('good', 'JJ'), ('.', '.')])

Mostrar un árbol de análisis sintáctico:

>>> from nltk.corpus import treebank

>>> t = treebank.parsed_sents('wsj_0001.mrg')[0]

>>> t.draw()

Como estoy usando nltk 3, debo usar python 3. Otra cosa importante tienen que tener instalado python3-tk.

Ojo que si quieren probar estos ejemplos deben hacer :

>>> nltk.download()

Y ahí tienen que bajar los paquetes. 

Tenemos un libro gratuito y online: http://www.nltk.org/book/

Dejo link:
https://www.nltk.org/

5 Cursos de Spring Gratuitos

Si queremos aprender una tecnología nueva lo mejor es empezar por un libro o un curso y luego ir a tutoriales de internet. Saltar de tutorial en tutorial, nos da el conocimiento pero nos falta el orden. Con un curso o un libro aprendemos ordenadamente, como debe ser.

Por lo tanto dejo 5 cursos gratuitos para todos los que quieran empezar con Spring :

• Spring Framework And Dependency Injection For Beginners
• Introducing Spring Boot
• Spring Fundamentals
• Introduction to Spring MVC 4
• Spring & Hibernate for Beginner 

Un ejemplo utilizando Apache Spark Streaming

Lo que vamos a hacer es un proceso que escuche lo que escribimos con "nc" en el puerto 9999. Y luego vamos a contar, es decir vamos a contar las palabras.

Iniciamos spark-shell :

./spark-shell

Luego debemos importar todos los objetos para hacer streaming:

import org.apache.spark._
import org.apache.spark.streaming._
import org.apache.spark.streaming.StreamingContext._

//Ahora hacemos el contexto de streaming, utilizando el contexto de mi aplicación. A la vez //especificamos el periodo de tiempo que se debe procesar los datos:

val ssc = new StreamingContext(sc, Seconds(10))

// Creamos el DStream para localhost:9999
val lines = ssc.socketTextStream("localhost", 9999)

// indicamos las tareas a realizar con los datos.
val words = lines.flatMap(_.split(" "))
val pairs = words.map(word => (word, 1))

val wordCounts = pairs.reduceByKey(_ + _)

// Imprima los primeros elementos de cada RDD generado en este DStream para la consola

wordCounts.print()

ssc.start()             // comenzamos
ssc.awaitTermination()  // Espere a que termine el cálculo

Y listo, ahora si vamos a otra consola y escribimos :

nc -lk 9999

Este comando va a escribir lo escribimos en el puerto 9999 y nuestra aplicación va a leerlo y contarlo.

Y eso es todo!!!

5 Cursos de Angular Gratuitos

Si queremos aprender una tecnología nueva lo mejor es empezar por un libro o un curso y luego ir a tutoriales de internet. Saltar de tutorial en tutorial, nos da el conocimiento pero nos falta el orden. Con un curso o un libro aprendemos ordenadamente, como debe ser.

Por lo tanto dejo 5 cursos gratuitos para todos los que quieran empezar con Angular :

• Learn Angular 5 from Scratch y Learn Angular 4 from Scratch
• Getting Started with Angular 2+
• Angular: Getting Started
• Angular Fundamentals
• AngularJS Authentication: Secure Your App with Auth0

Eclipse Foundation libero Eclipse Photon IDE

La Fundación Eclipse ha lanzado la última versión de Eclipse IDE. Eclipse Photon ofrece soporte para Java 10 y Java EE 8, mejoras para herramientas de desarrollo de PHP, mejoras de UI y más.

Java 10 es totalmente compatible con Eclipse Java Development Tools (JDT) y permite a los desarrolladores utilizar la inferencia de tipos variables  (JEP 286).

Eclipse Photon también ha agregado una función para convertir un proyecto de Java no modular a un módulo creando un module.info.java. Los desarrolladores también pueden crear un módulo pegando un fragmento de código que represente module-info.java directamente en una carpeta de origen para crear un archivo module-info.java.

El editor de Java se ha mejorado en Eclipse Photon de varias maneras. La coloración de sintaxis de Java se ha mejorado al usar el tema oscuro al reducir el uso de estilo en negrita y cambiar algunos colores que estaban demasiado cerca el uno del otro. Además, ahora es posible escapar de caracteres que no sean ASCII cuando se pegue en un literal de cadena.

Las herramientas de desarrollo de PHP han recibido una serie de mejoras, como soporte de validación para variables no utilizadas / no asignadas, validación para escalares en break / continue, validación para operaciones estáticas para PHP 7 o superior. Además, PHP Explorer ha sido reemplazado por el Explorador de proyectos. Una lista completa de características de PHP está disponible en la sección de PHP en la página Eclipse Photon New y Noteworthy.

Según la Fundación Eclipse, este lanzamiento incluye 85 proyectos con más de 73 millones de líneas de código, con la contribución de 620 desarrolladores, 246 de los cuales son Eclipse committers.

Sin más dejo link:
https://www.eclipse.org/org/press-release/20180627_new-photon-release-of-eclipse-ide-ships-with-full-rust-support.php

Ha descargar!!

5 cursos de Java Gratuitos

Si queremos aprender una tecnología nueva lo mejor es empezar por un libro o un curso y luego ir a tutoriales de internet. Saltar de tutorial en tutorial, nos da el conocimiento pero nos falta el orden. Con un curso o un libro aprendemos ordenadamente, como debe ser.

Por lo tanto dejo 5 cursos gratuitos para todos los que quieran empezar con Java :

• Java Tutorial for Complete Beginners
• Complete Java Masterclass
• Java - The Beginners Series
• Java Fundamentals: The Java Language
• Java Fundamentals - Part 1 and 2

5 cursos gratuitos de Git

Si queremos aprender una tecnología nueva lo mejor es empezar por un libro o un curso y luego ir a tutoriales de internet. Saltar de tutorial en tutorial, nos da el conocimiento pero nos falta el orden. Con un curso o un libro aprendemos ordenadamente, como debe ser.

Por lo tanto dejo 5 cursos gratuitos para todos los que quieran empezar con GIT :

• Git Started with GitHub
• The Ultimate GIT 5-day Challenge
• Getting Started With Git: Key Concepts for Beginners
• Command Line Essentials: Git Bash for Windows
• Short and Sweet: Get Started with Git and GitHub Right Now

La imagen es solo para entendidos ;)