Un Ejemplo de Polimorfismo en Java

La idea es mostrar un ejemplo de polimorfismo para los que comienzan a programar en el paradigma orientado a objetos.

La idea es que una empresa tiene un conjunto de bienes los cuales tienen un valor y a la vez algunos bienes pueden ser amortizados (La amortización es un término económico y contable, referido al proceso de distribución de gasto en el tiempo de un valor duradero. Adicionalmente se utiliza como sinónimo de depreciación en cualquiera de sus métodos.)

Los bienes se clasifican en inmuebles, muebles y rodados. A la vez los inmuebles no pierden el valor en el tiempo (es decir no son amortizables) . El software debe proveer una forma de saber el valor de todos los bienes y calcular su amortización.

Para resolver este problema vamos a definir 2 interfaces una que describa la característica que tienen los bienes de saber su valor y otra que describa la característica de calcular la amortización.

public interface Valorizable {

public Double getValor();

}

public interface Amortizable {

public Double calcularAmortizacion();

}

Programemos los bienes, empesamos con el mueble que para el ejemplo le puse Edificio:

import java.util.Calendar;
import java.util.Date;

public class Edificio implements Valorizable, Amortizable {

private Double valor;
private Date fechaDeCreacion;

public Edificio(Double valorInicial, Date fechaDeCreacion) {
this.valor = valorInicial;
this.fechaDeCreacion = fechaDeCreacion;
}

@Override
public Double calcularAmortizacion() {
Calendar cal = Calendar.getInstance();
int actualYear =cal.get(Calendar.YEAR);
cal.setTime(fechaDeCreacion);
int year =cal.get(Calendar.YEAR);
int diferencia = actualYear - year;
Double amortizacion = (diferencia * valor) / 300;
this.valor = this.valor - amortizacion;
return amortizacion;
}

@Override
public Double getValor() {
return this.valor;
}

@Override
public String toString() {
return "mueble " + this.valor;
}

}

Seguimos con el rodado:

public class Rodado implements Amortizable, Valorizable{

private static final Double VALOR_AMORTIZACION = 0.2;
private Double valor;
private Integer kms;

public Rodado(Double valorInicial, Integer kms) {
this.valor = valorInicial;
this.kms = kms;
}

public Double getValor() {
return valor;
}

public Double calcularAmortizacion() {
Double amotizacion = 0.0;
if (valor > 0.0) {
amotizacion = (VALOR_AMORTIZACION * kms.doubleValue())/100;
valor = valor - amotizacion;
}
return amotizacion;
}

@Override
public String toString() {
return "rodado " + this.valor;
}

}

Y por ultimo programemos el terreno: 

public class Terreno implements Valorizable {

private Double valor= 0.0;

private String direccion = "";

public Terreno(Double valor, String direccion) {

this.valor = valor;

this.direccion = direccion;

}

@Override

public Double getValor() {

return valor;

}

@Override

public String toString() {

return this.direccion;

}

}

De esta manera podemos tratar a todos los objetos amortizables como si fueran del mismo tipo y a todos los valorables como si fueran del mismo tipo, sin importarnos como calculan el valor o la amortización. 

Veamos el main: 

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Calendar;

import java.util.List;

public class Main {

public static void main(String[] args) {

// Construyo los Objetos

Calendar cal = Calendar.getInstance();

cal.set(1990, 02, 02);

Edificio unEdificio  = new Edificio(150000.00, cal.getTime());

Rodado unRodado = new Rodado(12000.00, 1000);

Terreno unTerreno = new Terreno(600000.00, "Los colibies 234");

List<Amortizable> list = new ArrayList<>();

list.add(unEdificio);

list.add(unRodado);

//list.add(unTerreno); No es posible agregar un terreno porque no es Amortizable

System.out.println();

System.out.println("Calcular Amortizacion");

for (Amortizable amortizar : list) {

System.out.println(amortizar.calcularAmortizacion());

}

List<Valorizable> list2 = new ArrayList<>();

list2.add(unEdificio);

list2.add(unRodado);

list2.add(unTerreno);

System.out.println();

System.out.println("Imprimir el valor");

for (Valorizable valorizar : list2) {

System.out.println(valorizar.getValor());

}

// En Java es común el uso de polimorfismo, veamos un ejemplo: 

List<Object> list3 = new ArrayList<>();

list3.add(unEdificio);

list3.add(unRodado);

list3.add(unTerreno);

list3.add("Hola!");

System.out.println();

System.out.println("Hacer to String");

for (Object object : list3) {

System.out.println(object.toString()); //toString es llamado de forma polimorfica.

}

}

}

Recuerden que el polimorfismo se refiere a la propiedad por la que es posible enviar mensajes sintácticamente iguales a objetos de tipos distintos. El único requisito que deben cumplir los objetos que se utilizan de manera polimórfica es saber responder al mensaje que se les envía.

Espero que les sirva!!

Un resumen de Scala for the Impatient, parte 23

Sobrescribir campos

Se puede sobrescribir val (o un método sin parámetros) con una declaración val con el mismo nombre. La clase tiene privados los atributos y públicos los getters y setters por lo tanto se sobrescribirán estos métodos.

Por ejemplo:

class Person(val name: String) {

     override def toString = getClass.getName + "[name=" + name + "]"

}

class SecretAgent(codename: String) extends Person(codename) {

     override val name = "secret" // Don’t want to reveal name . . .

     override val toString = "secret" // . . . or class name

}

Este ejemplo muestra el mecanismo, pero es bastante artificial. Un caso más común es sobrescribir un def de una clase abstracta, veamos un ejemplo :

abstract class Person { // See Section 8.8 for abstract classes

     def id: Int // Each person has an ID that is computed in some way

     ...

}

class Student(override val id: Int) extends Person

// A student ID is simply provided in the constructor

Note las siguientes restricciones:

• Un def solo puede ser sobrescrito por un def
• Un val solo puede ser sobrescrito por otro val o un def sin parámetros
• Un var solo puede ser sobrescrito por un var abstracto

Veamos un cuadro que describe la sobrecarga:

	Con val	Con def	Con var
Sobrescribir val	La subclase tiene un campo privado (con el mismo nombre que el campo de la superclase: está bien). Getter reemplaza al getter de superclase.	Error	Error
Sobrescribir def	La subclase tiene un campo privado. Getter anula el método de superclase.	Como java.	Una var puede anular un par getter / setter. Anular solo el getter produce un error.
Sobrescribir var	Error	Error	Sólo si la superclase var es abstracta

Subclases anónimas.

Como en java, se pueden implementar interfaces o extender clases abstractas implementando los métodos a continuación del llamado de dicha clase o interfaz, es más fácil explicar esto con un ejemplo:

val alien = new Person("Fred") {

     def greeting = "Greetings, Earthling! My name is Fred."

}

Técnicamente esto creo una persona con el método “greeting” implementado con el texto: "Greetings, Earthling! My name is Fred." El tipo es Person{def greeting: String}. Se puede utilizar este tipo como parámetro de la siguiente forma:

def meet(p: Person{def greeting: String}) {

     println(p.name + " says: " + p.greeting)

}

Clases Abstractas.

Como en java, podemos definir una clase abstracta con la palabra “abstract” y esta clase no se podrá instanciar. Normalmente esto es usado de la siguiente manera porque hay uno o más métodos que no podemos definir, es decir que son abstractos.

abstract class Person(val name: String) {

     def id: Int // No method body—this is an abstract method

}

Una subclase de Person va a estar obligada a implementar el método id o ser abstracta. A diferencia de java no es necesario utilizar la palabra abstract para los métodos, simplemente debemos omitir el cuerpo de la función.

Una subclase concreta esta obligada a sobre escribir este método:

class Employee(name: String) extends Person(name) {

     def id = name.hashCode // override keyword not required

}

Empezando con Elixir 5

Estructuras de control

if y unless

Si hemos programado estamos familiarizados con el if y en menor medida con el unless. Estas estructuras son construidas en elixir por medio de macros y no forma parte del lenguaje.

Por otra parte es necesario aclarar que en elixir solo es falso el nil y el false (por supuesto)

iex> if String.valid?("Hello") do
...>   "Valid string!"
...> else
...>   "Invalid string."
...> end
"Valid string!"

iex> if "a string value" do
...>   "Truthy"
...> end
"Truthy"

Se utiliza unless para analizar los casos falsos:

iex> unless is_integer("hello") do
...>   "Not an Int"
...> end
"Not an Int"

case

Esta estructura nos permite utilizar el pattern matching:

iex> case {:ok, "Hello World"} do
...>   {:ok, result} -> result
...>   {:error} -> "Uh oh!"
...>   _ -> "Catch all"
...> end

"Hello World"

El valor _ es similar al default de c o java. Y esto puede servir para prevenir errores:

iex> case :even do
...>   :odd -> "Odd"
...> end
** (CaseClauseError) no case clause matching: :even

iex> case :even do
...>   :odd -> "Odd"
...>   _ -> "Not Odd"
...> end
"Not Odd"

Dado que case se basa en pattern matching, se aplican todas las mismas reglas y restricciones. Si se quiere que coincida con variables existentes debe usar el operador pin ^ :

iex> pie = 3.14
 3.14
iex> case "cherry pie" do
...>   ^pie -> "Not so tasty"
...>   pie -> "I bet #{pie} is tasty"
...> end
"I bet cherry pie is tasty"

Permite tambien utilizar clausulas de protección:

iex> case {1, 2, 3} do
...>   {1, x, 3} when x > 0 ->
...>     "Will match"
...>   _ ->
...>     "Won't match"
...> end
"Will match"

cond

Cuando necesitamos hacer coincidir condiciones en vez de valores, podemos recurrir a cond.  Esto es similar a else if o elsif de otros lenguajes:

iex> cond do
...>   2 + 2 == 5 ->
...>     "This will not be true"
...>   2 * 2 == 3 ->
...>     "Nor this"
...>   1 + 1 == 2 ->
...>     "But this will"
...> end
"But this will"

Igual que case podemos tener un default que en este caso va ser el valor true :

iex> cond do
...>   7 + 1 == 0 -> "Incorrect"
...>   true -> "Catch all"
...> end
"Catch all"

with

with es útil cuando se puede usar una sentencia case anidada o situaciones que no se pueden canalizar de forma limpia. La expresión with se compone de las palabras clave, los generadores y, finalmente, una expresión.

Veamos un ejemplo simple y luego veremos algo más:

iex> user = %{first: "Sean", last: "Callan"}
%{first: "Sean", last: "Callan"}
iex> with {:ok, first} <- Map.fetch(user, :first),
...>      {:ok, last} <- Map.fetch(user, :last),
...>      do: last <> ", " <> first
"Callan, Sean"

En el caso de que una expresión no coincida, se devolverá un error:

iex> user = %{first: "doomspork"}
%{first: "doomspork"}
iex> with {:ok, first} <- Map.fetch(user, :first),
...>      {:ok, last} <- Map.fetch(user, :last),
...>      do: last <> ", " <> first
:error

Ahora veamos un ejemplo más grande sin with  y luego veamos cómo podemos refactorizarlo:

case Repo.insert(changeset) do
  {:ok, user} ->
    case Guardian.encode_and_sign(resource, :token, claims) do
      {:ok, token, full_claims} ->
        important_stuff(token, full_claims)
      error -> error
    end
  error -> error
end

Ahora usaremos with:

with {:ok, user} <- Repo.insert(changeset),
     {:ok, token, full_claims} <- Guardian.encode_and_sign(user, :token) do
  important_stuff(token, full_claims)
end

En Elixir 1.3 el with soporta el else:

import Integer

m = %{a: 1, c: 3}

a =
  with {:ok, number} <- Map.fetch(m, :a),
    true <- Integer.is_even(number) do
      IO.puts "#{number} divided by 2 is #{div(number, 2)}"
      :even
  else
    :error ->
      IO.puts "We don't have this item in map"
      :error
    _ ->
      IO.puts "It is odd"
      :odd
  end

Dejo link: https://elixirschool.com/lessons/basics/control-structures/

Un resumen de Scala for the Impatient, parte 22

Extender una Clase. 

Se puede extender una clase con la palabra extends :
class Employee extends Person {
var salary = 0.0
…
}

Como en Java, en la subclase se pueden agregar atributos y métodos y sobre escribir métodos existentes de la super clases.

Igual que Java, se pueden marcar las clases como final y no van a poder ser extendidas pero en scala se agrega que un método o atributo pueden ser final.

Sobre escribir métodos. 

En scala se debe utilizar el modificador override cuando se sobre escribe un método y este no es abstracto. Por ejemplo:

public class Person {
…
override def toString = getClass.getName + "[name=" + name + "]"
}

El modificador override es muy útil para encontrar errores muy comunes como los siguientes:

• Cuando se escribe mal el método que quiero sobre escribir
• Cuando se agrega un parámetro de más o de menos, y no tiene la misma firma. 
• Cuando se modifica el método padre en la super clase.

Si se desea llamar a un método del padre se hace igual que java se llama por medio de la palabra clave super.

public class Employee extends Person {
…
override def toString = super.toString + "[salary=" + salary + "]"
}

Al llamar a super.toString se esta llamando a el método toString de la clase Person.

Chequeo de tipos y casteos. 

El desarrollador puede saber si un objeto es de una clase determinada con el método isInstanceOf. Si esta clase es de un método determinado se puede castear utilizando asInstanceOf, veamos un ejemplo:

if (p.isInstanceOf[Employee]) {
val s = p.asInstanceOf[Employee] // s has type Employee
…
}

isInstanceOf retorna si un objeto es de una clase y  asInstanceOf hace el casteo.

Si p es null, isInstanceOf retorna false y asInstanceOf retorna null.

Si p no es un objeto Employee, asInstanceOf lanza una excepción.

Si es necesario saber que p es un empleado pero no una subclase de empleado lo hacemos de este modo:

if (p.getClass == classOf[Employee])

La función classOf esta definido en scala.Predef que siempre es importado.

A continuación se muestra una comparación con formas de chequeo de java:

Scala	Java
obj.isInstanceOf[Cl]	obj instanceof Cl
obj.asInstanceOf[Cl]	(Cl) obj
classOf[Cl]	Cl.class

A la vez el pattern matching es útil para saber los tipos:

p match {
case s: Employee => ... // Hacer cosas con el empleado
case _ => ... // p no es un empleado
}

Atributos y métodos protegidos

Como en java o c++ en scala existe los atributos o métodos protegidos, que son los que puede ver la clase y sus descendientes y no por otras clases.

Pero al contrario de java estos atributos no son visibles para los objetos de su paquete.

Constructor de la super clase.

Como recordaran existe un constructor principal de la clase y pueden existir n constructores auxiliares y que todos los constructores auxiliares llaman al constructor principal.

Como consecuencia de esto un constructor auxiliar no puede invocar a un constructor auxiliar de la super clase directamente.

El constructor auxiliares de la subclase deben llamar al constructor principal de la subclase y solo el constructor principal puede llamar al constructor principal de la super clase.

El constructor principal está relacionado con la definición de clase. La llamada al constructor de la superclase está igualmente relacionado. Veamos un ejemplo:

class Employee(name: String, age: Int, val salary : Double) extends
Person(name, age)

y el primer constructor llama al constructor de la super clase.

Note que el código es sumamente conciso y  podemos pensar a nuestro constructor principal con la mayoría de los datos y los auxiliares al llamarlo pondrán valores por defecto.

Una clase Scala puede extender de una clase java. Por ejemplo:

class Square(x: Int, y: Int, width: Int) extends
java.awt.Rectangle(x, y, width, width)

Un resumen de Scala for the Impatient, parte 21

Los imports pueden estar en cualquier lado.

En scala los import pueden estar en cualquier lugar. No solo en el principio del archivo. Por ejemplo:

class Manager {

import scala.collection.mutable._

val subordinates = new ArrayBuffer[Employee]

…

}

Esto es muy útil, dado que reduce las posibilidades de conflicto.

Renombrar y ocultar miembros.

En scala se pueden importar algunos miembros de un paquete usando el selector:

import java.awt.{Color, Font}

La sintaxis del selector permite renombrar las clases :

import java.util.{HashMap => JavaHashMap}

import scala.collection.mutable._

Ahora JavaHashMap es java.util.HashMap y HashMap es scala.collection.mutable.HashMap

El selector => _ es útil para ocultar una implementación. Esto es útil en el caso particular de que se quiera dejar de usar una clase para utilizar otro por ejemplo dentro de una clase:

import java.util.{HashMap => _, _}

import scala.collection.mutable._

Ahora HashMap es scala.collection.mutable.HashMap dado que java.util.HashMap se oculto.

Imports implícito.

Cada programa de scala se importan de forma implícita los siguientes paquetes:

import java.lang._

import scala._

import Predef._

Como es un programa Java se importa todas las clases de java.lang y luego se importan las clases de scala que en cierto caso pisan alas de java. Por ejemplo scala.StringBuilder pisa a java.lang.StringBuilder.

Y por ultimo se importa el objeto Predef. Que es un objeto que contiene funciones útiles.

Como el paquete scala es importado por defecto no es necesario importarlo luego, por ejemplo:

collection.mutable.HashMap es scala.collection.mutable.HashMap pero no es necesario escribir el comienzo del paquete.

Demuestra todo lo que sabes sobre la nube en el Azure Skills Challenge

Me llego el siguiente mail, me llamo la atención que es un juego, el cual sirve para publicitar  y enseñar Azure:

Demuestra todo lo que sabes sobre la nube en el Azure Skills Challenge

¿Aceptas el desafío?

Programación Funcional en Erlang

Me acabo de anotar en un curso de programación funcional en erlang que se dicta de forma gratuita, por la pagina futurelearn y la universidad de Kent (superman?) 

Comienza el 19 de este mes. 

Dejo link : https://www.futurelearn.com/courses/functional-programming-erlang/
https://www.cs.kent.ac.uk/

EdX en español !!!

El sitio de cursos Edx me envío el siguiente correo:

¡Ahora puedes experimentar el sitio web de edX en español! La página web edx.org/es ha mejorado para atender mejor a los estudiantes hispanohablantes, ahora es mucho más fácil la navegación en el sitio web y la búsqueda de cursos de las mejores universidades e instituciones a nivel mundial.  Cómo funciona: Si tu navegador está en español, no necesitarás hacer nada para experimentar el sitio en tu idioma. En caso de que lo necesites, tienes la opción de cambiar la configuración del idioma en el seleccionador del lenguaje al final de la página en edx.org/es. La página principal en idioma español y el sitio web tienen una variedad de cursos y programas, muchos enseñados en español y otros en inglés para beneficiarte de esta oferta única de instituciones de prestigio a nivel mundial.  ¡Visita el nuevo sitio web en español y comienza a aprender hoy mismo!

Empezar con programación funcional en la plataforma Java

Como ustedes sabrán Java no es un lenguaje funcional y por más que le agreguemos clausuras, no deja de ser un lenguaje orientado objetos con clausuras. Y la plataforma java sigue esta premisa, por lo tanto podemos afirmar que es imposible la programación funcional pura en java, y esto es cierto. Pero tambien es cierto que se puede programar de modo funcional con un lenguaje funcional no puro.

Vamos desde el principio, que es la programación funcional? Si vemos la wikipedia :

"En ciencias de la computación, la programación funcional es un paradigma de programación declarativa basado en el uso de funciones matemáticas, en contraste con la programación imperativa, que enfatiza los cambios de estado mediante la mutación de variables. La programación funcional tiene sus raíces en el cálculo lambda, un sistema formal desarrollado en los años 1930 para investigar la definición de función, la aplicación de las funciones y la recursión. Muchos lenguajes de programación funcionales pueden ser vistos como elaboraciones del cálculo lambda.

En la práctica, la diferencia entre una función matemática y la noción de una "función" utilizada en la programación imperativa, es que las funciones imperativas pueden tener efectos secundarios, como cambiar el valor de cálculos realizados previamente. Por esta razón carecen de transparencia referencial, es decir, la misma expresión sintáctica puede resultar en valores diferentes en varios momentos de la ejecución del programa. Con código funcional, en contraste, el valor generado por una función depende exclusivamente de los argumentos alimentados a la función. Al eliminar los efectos secundarios se puede entender y predecir el comportamiento de un programa mucho más fácilmente. Ésta es una de las principales motivaciones para utilizar la programación funcional.

Los lenguajes de programación funcional, especialmente los puramente funcionales, han sido enfatizados en el ambiente académico y no tanto en el desarrollo comercial o industrial. Sin embargo, lenguajes de programación funcional como Scheme, Erlang, Rust, Objective Caml , Scala, F# y Haskell, han sido utilizados en aplicaciones comerciales e industriales por muchas organizaciones. La programación funcional también es utilizada en la industria a través de lenguajes de dominio específico como R (estadística), Mathematica (matemáticas simbólicas), J y K (análisis financiero)." https://es.wikipedia.org/wiki/Programaci%C3%B3n_funcional

Pero que mide la pureza de un lenguaje funcional? Un lenguaje funcional es puro respecto de la integridad referencial. No permite ningún efecto colateral. Probablemente, sea su característica más importante. Y volviendo a la plataforma java no podemos asegurar esto, porque esta plataforma nacio basada en un paradigma que mantiene estados. De igual manera existen lenguajes en la plataforma que nos permiten ser bastante puros como es el caso de los lenguajes basados en Haskell como Frege
y Jaskell.

Con respecto a los lenguajes la plataforma Java cuenta con varios lenguajes funcionales y con Java, si Java es un lenguaje de la plataforma Java y este como ya lo saben no es funcional. Es decir a partir de java 8 se pueden utilizar lambda, pero eso es solo una característica de la programación funcional, no hace a java funcional. De igual manera existen framework que suman azúcar sintáctico para programar en java de modo funcional :

• Functional Java
• Google guava
• LambdaJ
• Fun4J
• JCurry
• OCaml-Java
• Jambda
• Bolts
• Functional Java (swensen.functional)

Con respecto a los lenguajes, la plataforma java tiene varios lenguajes funcionales es su plataforma: 

• Clojure (basado en lisp)
• Scala
• Basados en Haskell:
• Frege
• Jaskell
• Basado en Scheme:
• Bigloo 
• Kawa 
• SISC 
• JScheme 
• Yeti (Basado en ML) 

Y esto es simplemente para nombrar algunos porque varios lenguajes tienen características funcionales y corren en la plataforma de java, como por ejemplo Kotlin o Ceylon. 

En conclusión java es una buena plataforma para programación funcional, si bien no se puede implementar la programación funcional pura a nivel de plataforma provee lenguajes muy puros como Frege o Jaskell. Lo que pasa es que tampoco es fácil hacer una plataforma multiparadigma en serio. Conocen una plataforma la cual pueda ejecutar lenguajes funcionales puros y orientados a objetos? 

Masivo de correos, la forma más fácil y rápida de hacer de publicitar tu empresa

No es muy común esta clase de post en el blog pero tuve una respuesta positiva enviando mails masivos. Por lo que quiero compartir con ustedes mi experiencia.

Que es el Email marketing??  Se lo conoce como ciberbuzoneo  o en inglés: e-mailing es un método de marketing directo que utiliza el correo electrónico como medio de comunicación comercial para enviar mensajes a una audiencia. De esta forma podes tener al tanto a tus clientes de las novedades de tu empresa, nuevos productos, ofertas, etc...

Si buscamos email marketing en la wikipedia:

"La publicidad por correo electrónico, email marketing, marketing por email, correo comercial o email comercial,1 es enviar un mensaje comercial directamente utilizando como canal el correo electrónico. En su sentido más amplio, cada email que se envía a un cliente o potencial cliente puede ser considerado como email marketing. Normalmente implica utilizar un correo para enviar anuncios, peticiones de negocios, solicitar ventas o donaciones, y está principalmente orientado a crear lealtad, confianza, o concienciación de marca.

La publicidad por correo electrónico puede efectuarse a listas compradas o una base de datos de clientes actual. En términos generales, el término marketing por email es normalmente utilizado para referirse a enviar mensajes de email con el propósito de mejorar la relación de una empresa con sus clientes actuales o anteriores, para generar lealtad del cliente y empresarial, adquiriendo clientes nuevos o convenciendo clientes actuales para adquirir algo inmediatamente, y añadiendo los anuncios a mensajes de email enviados por otras compañías a sus clientes."

Pero preparar una campaña de envío masivo de correos no es algo que se deba hacer a la ligera, dado que podemos ser vistos como spammer. El spammer hacen referencia a los mensajes no solicitados, no deseados o con remitente no conocido (correo anónimo), habitualmente de tipo publicitario, generalmente son enviados en grandes cantidades (incluso masivas) que perjudican de alguna o varias maneras al receptor. Pero si lo que enviamos al usuario es información útil y cuidada el puede ver con buenos ojos estos correos.

Para evitar caer en la bandeja de spam de tus suscriptores es interesante que cumplas con los siguientes factores:

• Trabaja siempre con una base de datos propia actualizada y segmentada. Muchas empresas envían sin problemas cada día cientos de miles de correos electrónicos en campañas de Email Marketing orientadas a convertir sus listas de registros en clientes.
• Tus mensajes deben ser relevantes siempre. Si tienes alguna duda, revisa y analiza los contenidos tanto de texto como audiovisuales para garantizar que son realmente de interés para quien los va a recibir.
• No olvides incluir un enlace de baja de la suscripción bien visible. No tiene sentido seguir enviando emails a usuarios que no quieren recibirlos. No sólo es un riesgo que corre tu empresa de ser calificada por dichos usuarios como spam sino que, lo que es peor, es una inversión sin justificación ni retorno. Si no quieren recibir tus emails mejor que se puedan dar de baja fácilmente. Piensa siempre en tus usuarios, si muchos se dan de baja reflexiona sobre los contenidos que ofreces y adáptalos a tu audiencia.

Por otro lado, debes contar con una herramienta profesional para realizar el envío masivo de correos. Aunque algunas de las aplicaciones de correo electrónico habituales pueden ser utilizadas para lanzar ciertos mensajes, a partir de un número determinado comienzan a pesar más sus desventajas.

Todas las plataformas profesionales diseñadas para enviar miles de correos a la vez respetan la legalidad, funcionan con proveedores de servicios de internet de calidad con el fin de asegurar que tus correos son enviados y te ofrecen unas estadísticas y un soporte que resolverá tus dudas y, sobretodo, te permitirá tomar las decisiones adecuadas para mejorar la eficacia de tus campañas de Email Marketing.

Como conclusión les aconsejo que vean con buenos ojos el envio de correos masivos dado que si se lo realiza correctamente es una excelente oportunidad para su empresa. 

Dejo link: https://es.wikipedia.org/wiki/Email_marketing

Cristal, rápido como C, amigable como Ruby

Cristal es un lenguaje similar a ruby que viene creciendo bastante, entre sus características podemos nombrar:

Sintaxis: La sintaxis de cristal es muy similar a la de ruby, lo que lo hace fácil de leer y de escribir.

Veamos un ejemplo:

# A very basic HTTP server
require "http/server"

server = HTTP::Server.new(8080) do |context|
  context.response.content_type = "text/plain"
  context.response.print "Hello world, got #{context.request.path}!"
end

puts "Listening on http://127.0.0.1:8080"
server.listen


Es un lenguaje compilado, lo que lo hace más rápido y con menos uso de memoria.

Chequeo de tipos, cristal es de tipado estático y hace chequeos de tipo en tiempo de compilación.

Chequeo de posibles errores por valores nulos. 

if rand(2) > 0
  my_string = "hello world"
end


puts my_string.upcase

y si compilamos:

$ crystal hello_world.cr
Error in hello_world.cr:5: undefined method 'upcase' for Nil (compile-time type is (String | Nil))

puts my_string.upcase
                        ^~~~~~

Macros, que permiten extender el lenguaje:

class Object
  def has_instance_var?(name) : Bool
    {{ @type.instance_vars.map &.name.stringify }}.includes? name
  end
end

person = Person.new "John", 30
person.has_instance_var?("name") #=> true
person.has_instance_var?("birthday") #=> false

y mucho más!!


Dejo link:
https://crystal-lang.org/

Empezando con Elixir 4

Pattern Matching

Pattern Matching es una parte importante y poderosa de elixir. Esto permite machear valores simples, estructura de datos e incluso funciones. Veamos como trabaja:

El operador Match
En elixir el operador = es un operador de macheo. Elixir espera que coincida los valores de la mano izquierda con los valores de la mano derecha. Si coinciden, devuelve el valor de la ecuación. De lo contrario, se produce un error. Vamos a ver un ejemplo:

iex> x = 1
1

Ahora vamos a probar el macheo:

iex> 1 = x
1
iex> 2 = x
** (MatchError) no match of right hand side value: 1

Ahora veamos ejemplos con varias estructuras:

# Lists
iex> list = [1, 2, 3]
iex> [1, 2, 3] = list
[1, 2, 3]
iex> [] = list
** (MatchError) no match of right hand side value: [1, 2, 3]

iex> [1 | tail] = list
[1, 2, 3]
iex> tail
[2, 3]
iex> [2 | _] = list
** (MatchError) no match of right hand side value: [1, 2, 3]

# Tuples
iex> {:ok, value} = {:ok, "Successful!"}
{:ok, "Successful!"}
iex> value
"Successful!"
iex> {:ok, value} = {:error}
** (MatchError) no match of right hand side value: {:error}

Operador Pin

El operador de = realiza la asignación cuando el lado izquierdo de la coincidencia incluye una variable. En algunos casos, este comportamiento no es deseable. Para estas situaciones tenemos el operador pin: ^.

Veamos un ejemplo:

iex> x = 1
1
iex> ^x = 2
** (MatchError) no match of right hand side value: 2
iex> {x, ^x} = {2, 1}
{2, 1}
iex> x
2


iex> key = "hello"
"hello"
iex> %{^key => value} = %{"hello" => "world"}
%{"hello" => "world"}
iex> value
"world"
iex> %{^key => value} = %{:hello => "world"}
** (MatchError) no match of right hand side value: %{hello: "world"}

En Elixir 1.2 se agrega soporte para que el pin funcione en mapas o funciones.

iex> key = "hello"
"hello"
iex> %{^key => value} = %{"hello" => "world"}
%{"hello" => "world"}
iex> value
"world"
iex> %{^key => value} = %{:hello => "world"}
** (MatchError) no match of right hand side value: %{hello: "world"}

Veamos un ejemplo con funciones:

iex> greeting = "Hello"
"Hello"
iex> greet = fn
...>   (^greeting, name) -> "Hi #{name}"
...>   (greeting, name) -> "#{greeting}, #{name}"
...> end
#Function<12.54118792/2 in :erl_eval.expr/5>
iex> greet.("Hello", "Sean")
"Hi Sean"
iex> greet.("Mornin'", "Sean")
"Mornin', Sean"

Dejo link: https://elixirschool.com/lessons/basics/pattern-matching/

9 lenguajes que deberías aprender en el 2017

Muy pocas veces me encuentro con un articulo que dice que debemos aprender algo y coincido, normalmente son tecnologías ya consolidadas pero esta vez me encontré con un articulo que no le importo hacer futurología y tiro algunos nombres de lenguajes que son poco comunes en estas listas.

Los lenguajes que debemos aprender son:

• Kotlin: como era de esperar, todo el mundo habla de él luego de convertirse en el lenguaje soportado por Android. 
• Elm: Lenguaje funcional por demás interesante, permite compilar a html y javascript.
• Julia: Similar a python pero dedicado a la ciencia. 
• Elixir: Lenguaje funcional que hemos hablado ciento de veces en el blog.
• Rust: Lenguaje de propósito general, que se parece mucho a C++
• Crystal: Este si no lo conocía, se viene un post en breve. 
• Groovy: En serio? yo creía que venia bajando su popularidad y de repente aparece en esta lista. 
• R: Si haces algo con estadísticas debes conocer a R, es un lenguaje funcional dedicado a la estadísticas, que cada vez adquiere más adeptos. 
• Go: El lenguaje de google viene lento pero seguro ganando mercado. 

Entre las cosas que me llamaron la atención puedo nombrar:

• El 90% de los lenguajes nombrados tienen al menos un post en el blog! (tengo que hacer algo de publicidad)
• Podríamos decir que la mitad o más son lenguajes funcionales, o que aplican técnicas de programación funcional, Entonces, a aprender funcional, no?

Por lo tanto decidí compartir este articulo:
http://www.rankred.com/new-programming-languages-to-learn/

Un resumen de Scala for the Impatient, parte 20

Encadenado de paquetes

La definición de paquetes puede tener nombres encadenados por punto, por ejemplo:

package com.horstmann.impatient {
   package people {
     class Person
     …
  }
}

Notación Top-of-File

Similar a java podemos optar por notación al principio de la clase, este paquete va a finalizar en el final del archivo. Por ejemplo:

package com.horstmann.impatient
package people
class Person
…

Esto es similar a :

package com.horstmann.impatient {
package people {
class Person
...
// Until the end of the file
}
}

Esta notación es útil cuando tenemos un solo paquete para todo un archivo.

Objetos paquete

Un paquete puede contener object, class o traits pero no una definición de funciones o variables por limitaciones en la maquina virtual java. Pero se puede definir un objeto paquete, este objeto contendrá variables o funciones globales en el paquete.

Veamos un ejemplo:

package com.horstmann.impatient
package object people {
val defaultName = "John Q. Public"
}
package people {
class Person {
var name = defaultName // A constant from the package
}
...
}

Note que defaultName no es necesario dado que se encuentra en un objeto con el mismo nombre del paquete, y podemos acceder a los valores desde otro paquete con el siguiente nombre: com.horstmann.impatient.people.defaultName

Es buena idea crear usar el mismo esquema de paquetes que los directorios de los archivos fuente. Y podemos poner un archivo package.scala donde van a estar los objetos de paquete, para tener una convención.

Visibilidad de paquetes. 

En java si una clase no es declarada como publica, privada o protected, es default y solo puede ser vista en el paquete. En scala existen calificadores que nos permiten hacer esto y tener mayor control de la visibilidad:

package com.horstmann.impatient.people
class Person {
private[people] def description = "A person with name " + name
...
}

Y se puede extender la visibilidad a paquetes padres:

private[impatient] def description = "A person with name " + name

Imports

Podemos importar una clase particular, para no utilizar el nombre largo:

import java.awt.Color

o podemos importar todos los elementos de un paquete de la siguiente manera:

import java.awt._

Como podemos ver es similar al * de java. También se pueden importar todos los miembros de una clase o objeto:

import java.awt.Color._
val c1 = RED // Color.RED
val c2 = decode("#ff0000") // Color.decode

Esto es similar a static import de java.

Importado todo un paquete podemos acceder a los objetos o clases de los subpaquetes con el nombre del subpaquete + el nombre de la clase o objeto:

import java.awt._
def handler(evt: event.ActionEvent) { // java.awt.event.ActionEvent
...
}

Como dice el comentario estamos usando  java.awt.event.ActionEvent cuando nombramos  event.ActionEvent porque  java.awt fue importado en su totalidad.

Realm. un sitio donde publican buenos cursos.

Quiero compartir este sitio, donde publican buenos cursos que son bastantes teóricos.

Hay de todos los temas, pero los temas más importantes:

• Android  
• Apple  
• Javascript  
• Xamarin  
• Architecture

Y encontré muy buenos cursos sobre programación funcional.

Dejo link: http://news.realm.io/news