Aprende Haskell por amor a vos!!

Como ustedes sabrán estoy estudiando Scala, Elixir y otros lenguajes pero por un revés de la vida me ha llevado a retomar mis estudios de Haskell.

Porque es buena idea estudiar Haskell y no solo programación funcional? Bueno se me ocurren las siguientes razones:

1. Es un lenguaje funcional puro, es como aprender objetos con Smalltalk, la mejor opción para aprender un paradigma es utilizar el lenguaje más puro que aplique este paradigma.
2. Es de tipado estático: Cuando compilamos un programa, el compilador sabe que una función es entera, cuales son cadenas de texto, etc. Gracias a esto un montón de posibles errores son capturados en tiempo de compilación. Si intentamos sumar un número y una cadena de texto, el compilador lanzara un error. Haskell usa un fantástico sistema de tipos que posee inferencia de tipos. Esto significa que no tenemos que etiquetar cada trozo de código explícitamente con un tipo porque el sistema de tipos lo puede deducir de forma inteligente. La inferencia de tipos también permite que nuestro código sea más general, si hemos creado una función que toma dos números y los suma y no establecemos explícitamente sus tipos, la función aceptará cualquier par de parámetros que actúen como números.
3. Haskell es elegante y conciso. Básicamente tenemos toda las ventajas de la programación funcional, por lo tanto los programas Haskell son normalmente más cortos que los equivalentes imperativos. Y los programas cortos son más fáciles de mantener que los largos, además de que poseen menos errores. 
4. Haskell es un lenguaje codicioso, no el lenguaje, los que lo diseñaron. Ellos hicieron que haskell sea puro y que siempre tome el camino más puro para resolver los problemas. Haskell implementa un montón de conceptos lo cual trae con sigo que aprendamos mucho. Y esos conceptos sean interpolables a otros lenguajes. 
5. Haskell fue creado por unos tipos muy inteligentes (todos ellos con sus respectivos doctorados). El proyecto de crear Haskell comenzó en 1987 cuando un comité de investigadores se pusieron de acuerdo para diseñar un lenguaje revolucionario. En el 2003 el informe Haskell fue publicado, definiendo así una versión estable del lenguaje.
6. Es divertido! Si te gusta aprender y resolver problemas, este lenguaje es para vos!

Un lugar muy bueno para empezar es : http://aprendehaskell.es/

IntelliJ IDEA Handbook Gratis!!

Javacodegeeks regala el libro "IntelliJ IDEA Handbook " y aca te dejamos el link:

https://www.javacodegeeks.com/minibook/intellij-idea-handbook

Vala un lenguaje para programar con GTK+ 3

Vala un lenguaje para programar parecido a C# pero con reformas para programar con GTK+ 3, ideal para programar interfaces linux pero tambien se puede utilizar en Windows o Mac.

Es un lenguaje sumamente simple de tipado estático. Que hace muy fácil la programación de interfaces gráficas.

Veamos un ejemplo:

Primero instalar las librerías : sudo apt-get install valac libgtk-3-dev

luego programamos un Hola mundo:

class Aplication : GTK.Window{

public static int main(string[] args) {

# Inicializamos Gtk con argumentos
Gtk.init (ref args);

# Creamos la aplicación.
Application app = new Application ();

# Ponemos la aplicación al centro de la pantalla.
app.window_position = Gtk.WindowPosition.CENTER;

#  Al cerrar destruimos la app.
app.destroy.connect (Gtk.main_quit);

# Medimos la ventana
app.set_default_size (100, 50);

# Creamos un botón  y conectamos el evento clikear del botón y imprimimos un hola!
var button = new Gtk.Button.with_label ("Saluda");
button.clicked.connect (() => {
print("Hola!\n");
});

# Añadimos el botón a la app
app.add(button);

# Mostramos la App/Ventana
app.show_all ();

}
}

Luego lo guardamos y ahora debemos compilarlo y ejecutar:

$ valac -v lol.vala --pkg gtk+-3.0
$ ./lol

Y listo!!

Aplaudimos de pie que las herramientas obtén por dar soporte a lenguajes más modernos. GTK 3 se viene con todo!!

Dejo link: https://developer.gnome.org/gnome-devel-demos/stable/beginner.vala.html.en
https://wiki.gnome.org/Projects/Vala/GTKSample

Beneficios de la programación funcional

Siguiendo con el post anterior, nombro algunos beneficios de la programación funcional:

• Serás mejor programador: tu forma de pensar en el código y de afrontar los problemas será muy distinta. Con la programación funcional aprenderás afrontar los problemas de computación y de plantear la mejor solución posible: a plantear soluciones de formas que nunca habías pensado, mucho más simples y eficientes.
• Código más simple, limpio y con menos bugs: solo por este motivo ya merece la pena. Tendrás menos código, menos variables, menos estructuras de control, no hay nulos ... así que cometerás menos errores escribiendo código. Además el compilador te ayudará a detectarlos antes que nadie.
• Podrás resolver problemas más complejos: la esencia de la programación funcional es la simpleza: buscar soluciones simples. Y cuando más simple sea tu solución, mayores problemas podrás resolver. Joel Spolsky, el fundador de StackOverflow y Trello, decía: Without understanding functional programming, you can’t invent MapReduce. A eso me refería, problemas realmente complejos son muy difíciles de resolver (de entender, de implementar, de testear...) con código imperativo.
• Código más versátil: las abstracciones y tipos que definas serán totalmente reutilizables. Como dijo Joe Armstrong, creador del lenguaje funcional Erlang, con la OOP tú coges un plátano (un objeto), pero con él te traes al gorila y a la jungla entera (todas sus dependencias). ¿Te suena?
• Mejor concurrencia y asincronismo: hoy en día los dispositivos tienen varios cores para ejecutar código en paralelo, por lo que este punto es esencial. Podrás evitar el famoso callback hell!
• Y por último, aumentará tu valor como programador: una cosa es que seas buen programador y otra muy diferente es que los demás lo perciban a la primera. La programación funcional te permitirá destacar entre el resto y tu valor como programador se multiplicará.

¿qué es la programación funcional? y en qué consiste?

Es un paradigma que te recomienda lo que debes, pero sobre todo, lo que no debes hacer. Veamos los principios donde se apoya este paradigma:

• Datos inmutables: son variables que no varían, bueno como constantes entonces ... el concepto de variable como la conocemos desaparece, dando lugar a datos inmutables. 
• Código declarativo: en vez de describir una serie de pasos o instrucciones, tienes que declarar lo que quieres obtener, concatenando una serie de expresiones, sin preocuparte de qué hacen por dentro esas expresiones. Es como que te pida un café, vos me vas a dar un café, pero yo no te di las instrucciones para que los prepares. 
• Funciones sin efectos colaterales: no basta con escribir funciones para “organizar” o reutilizar tu código. O esas funciones cumplen unas reglas muy sencillas que te van a ahorrar muchos quebraderos de cabeza. Siempre una funcion con un determinado valor retorna el mismo resultado, siempre. 
• Recursión: seguro que has utilizado alguna vez un algoritmo recursivo… cuando no te quedaba más remedio. ¿Y si te digo que en lenguajes funciones no hay otra forma de hacer bucles?
• Funciones de orden superior: ¿y si pudiésemos hacer con las funciones lo mismo que hacemos con otros tipos de datos? Pues de eso se trata, de usar funciones como si fueran números o cadenas de texto. Es decir se pueden utilizar como parámetro o tambien retornar de otra función.

La programación funcional llega a Android

Con la llegada de Kotlin a Android, llego la programación funcional. Si bien java 8 tiene varios aspectos funcionales, no se compara con Kotlin que nos acerca mucho más a la programación funcional en serio.

Seguramente, la programación que ya conoces y utilizas cada día consiste en ejecutar líneas de código, una detrás de la otra, decidir el flujo con bucles y condicionales, y jugar con variables. Si eres un programador OOP, a esto le añadimos que todo esto lo “empaquetamos” en lo que llamamos clases, y luego jugamos con esas clases.

Pero hay formas muy distintas de hacer las cosas. Una de ellas es precisamente la programación funcional, de la que seguro que has oído hablar mucho últimamente.

variables, bucles, constantes, clases, funciones... seguramente te parezcan la forma única de programar, o al menos así se ha enseñado en muchos sitios. Sin embargo, hay formas distintas de programar, que te permitirá resolver problemas mucho más avanzadas que con el estilo de programación que ya conoces.

El tipo de programación que utilizas todos los días, es decir, el código que utiliza variables, bucles, clases, etc. es conocido como Programación Imperativa. Los lenguajes de programación más populares pertenecen a este tipo: C/C++, Java, Python, PHP...

Y por si te lo estás preguntando... sí, la Programación Orientada a Objetos (OOP) pertenece a esta categoría, digamos que es una "subcategoría" de la Programación Imperativa.

Por otro lado, tenemos la Programación Funcional, que es un paradigma que no necesita ni variables, ni bucles, ni nada de lo anterior para programar. Utiliza unas herramientas distintas: principalmente funciones y pensar de forma distinta a la hora de escribir tu código.

Y si programar se trata de dar soluciones a distintos problemas, ¿por qué utilizamos siempre el mismo paradigma para resolver todos los problemas? ¿No tendría más sentido usar el estilo que mejor resuelva cada problema?

Así que, si somos programadores imperativos, no es porque en algún momento hayamos elegido el mejor camino, sino porque en aquellos años el estilo funcional no era viable, y a partir de ahí, cayó en desuso y se olvidó. Hasta ahora...

El lenguaje de Kotlin puede parecer a primera vista nada más que una versión mejorada de Java: muchos aspectos de sintaxis, algunos tipos de inferencia, etc. Pero si profundizamos un poco más y descubriremos que muchas de las características más populares y avanzadas de los lenguajes funcionales están disponibles. Como por ejemplo: 

• Tipos de datos algebraicos
• Inmutables
• funciones recurcivas 
• funciones como: Mapping, filtering, reducing etc
• Currying
• Lazyness

Para que no quede tan largo el post, continuara... 

Libro gratuito: Diseño de equipos y servicios autónomos

Los equipos de desarrollo de alto rendimiento poseen sus productos de extremo a extremo, desde la interacción del cliente hasta la entrega exitosa. Pero, ¿cómo ganan ese nivel de independencia en primer lugar?

En el libro : Designing Autonomous Teams and Services, los autores Nick Tune y Scott Millett examinan cómo las organizaciones líderes como Salesforce y Spotify aumentan la autonomía de los equipos y servicios. Los casos de uso múltiple demuestran la forma en que los equipos establecen y mantienen la autonomía, utilizando el descubrimiento de los servicios y la entrega continua para crear las mejores soluciones con el mayor valor comercial.

Les dejo este libro gratuito que parece por demás interesante

Dejo link: https://conferences.oreilly.com/software-architecture/sa-ny/public/content/designing-autonomous-teams-and-services?imm_mid=0f75e3&cmp=em-prog-confreg-na-sany18_nurture_em1_autonomous_teams

Juego de Serie en c++ con QT

Vamos a tomar el juego : http://emanuelpeg.blogspot.com.ar/2017/10/juego-de-serie-en-c.html y lo llevaremos a qt.

Para eso debemos hacer un nuevo proyecto qt y llevar nuestras clases. Y ahora vamos a programar las pantallas, Vamos a hacer una ventana que se llame MainWindows (original lo mio) :

MainWindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include "juego.h"

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();


private slots:
    void on_pushButton_clicked();

private:
    Ui::MainWindow *ui;
    Juego juego;
    void dibujar();
};

#endif // MAINWINDOW_H

Como vemos hemos agregado una propiedad de tipo juego. Veamos el cpp : 

#include "mainwindow.h"

#include "ui_mainwindow.h"

#include <QMessageBox>

#include <QString>

MainWindow::MainWindow(QWidget *parent) :

    QMainWindow(parent),

    ui(new Ui::MainWindow)

{

    ui->setupUi(this);

    this->dibujar();

}

MainWindow::~MainWindow()

{

    delete ui;

}

void MainWindow::dibujar() {

    ui->label->setText(QString::number(juego.getValor0()));

    ui->label_2->setText(QString::number(juego.getValor1()));

    ui->label_3->setText(QString::number(juego.getValor3()));

    ui->spinBox->setValue(0);

}

void MainWindow::on_pushButton_clicked()

{   QString msg;

    if (juego.validar(ui->spinBox->value())) {

        msg = "ganaste  Puntaje:"+ QString::number(juego.getPuntos());

    } else {

        msg = "perdio Puntaje:"+ QString::number(juego.getPuntos());

    }

    QMessageBox::warning(this, tr("Resultado"),

                                       msg,

                                       QMessageBox::Ok  ,

                                       QMessageBox::Ok);

    this->dibujar();

}

Ya se no se entiende bien por que falta el diseño de la pantalla : 

<?xml version="1.0" encoding="UTF-8"?>

<ui version="4.0">

 <class>MainWindow</class>

 <widget class="QMainWindow" name="MainWindow">

  <property name="geometry">

   <rect>

    <x>0</x>

    <y>0</y>

    <width>496</width>

    <height>105</height>

   </rect>

  </property>

  <property name="windowTitle">

   <string>Secuencia</string>

  </property>

  <widget class="QWidget" name="centralWidget">

   <layout class="QHBoxLayout" name="horizontalLayout">

    <item>

     <widget class="QLabel" name="label">

      <property name="text">

       <string>TextLabel</string>

      </property>

     </widget>

    </item>

    <item>

     <widget class="QLabel" name="label_2">

      <property name="text">

       <string>TextLabel</string>

      </property>

     </widget>

    </item>

    <item>

     <widget class="QSpinBox" name="spinBox">

      <property name="minimum">

       <number>-9999999</number>

      </property>

      <property name="maximum">

       <number>9999999</number>

      </property>

     </widget>

    </item>

    <item>

     <widget class="QLabel" name="label_3">

      <property name="text">

       <string>TextLabel</string>

      </property>

     </widget>

    </item>

    <item>

     <widget class="QPushButton" name="pushButton">

      <property name="text">

       <string>verificar</string>

      </property>

     </widget>

    </item>

   </layout>

  </widget>

  <widget class="QMenuBar" name="menuBar">

   <property name="geometry">

    <rect>

     <x>0</x>

     <y>0</y>

     <width>496</width>

     <height>25</height>

    </rect>

   </property>

  </widget>

  <widget class="QToolBar" name="mainToolBar">

   <attribute name="toolBarArea">

    <enum>TopToolBarArea</enum>

   </attribute>

   <attribute name="toolBarBreak">

    <bool>false</bool>

   </attribute>

  </widget>

  <widget class="QStatusBar" name="statusBar"/>

 </widget>

 <layoutdefault spacing="6" margin="11"/>

 <resources/>

 <connections/>

</ui>

Ahora si, como vemos agregamos unos labels que muestran los números y un spinBox que permite ingresar números. Y luego con un botón los validamos. 

Como se puede apreciar el diseño del juego permite generar una interfaz de consola o en qt o en otra tecnología esta es la mayor ventaja de separar nuestros objetos de la capa de presentación. 

Dejo el repositorio git: https://github.com/emanuelpeg/secuanciaQt 

Ceph

Si tu organización ejecuta aplicaciones con diferentes almacenes de datos, ¡Ceph es para vos! Ceph es un almacén de datos confiable de objetos distribuidos y autónomos (RADOS), que proporciona a sus aplicaciones el almacenamiento de objetos, bloques y sistemas de archivos en un solo cluster de almacenamiento unificado, lo que hace que Ceph sea flexible, altamente confiable y fácil de administrar.

Ceph's RADOS le ofrece una escalabilidad de almacenamiento de datos extraordinaria: miles de hosts de clientes o KVM que acceden a petabytes a exabytes de datos. Cada una de sus aplicaciones puede usar el objeto, el bloque o las interfaces del sistema de archivos al mismo grupo RADOS al mismo tiempo, lo que significa que su sistema de almacenamiento Ceph sirve como una base flexible para todas sus necesidades de almacenamiento de datos. Puede usar Ceph de forma gratuita y desplegarlo en hardware económico. Ceph es una mejor forma de almacenar datos.

El sistema de almacenamiento de objetos de Ceph no está limitado a enlaces nativos o API RESTful. ¡Puedes montar Ceph como un dispositivo de bloque de aprovisionamiento delgado! Cuando escribe datos a Ceph utilizando un dispositivo de bloque, Ceph graba automáticamente y replica los datos en el clúster.

Ceph proporciona una interfaz de sistema de archivos tradicional con semántica POSIX. Los sistemas de almacenamiento de objetos son una innovación significativa, pero muchas veces tratan de reemplazar, los sistemas de archivos tradicionales.

Dejo link:  http://ceph.com

Dejo un video:

Los 15 lenguajes más utilizados en github

Leí un articulo sobre los 15 lenguajes más usados en github y no me lleve ninguna sorpresa, el primero es javascript. Sin duda el lenguaje más de moda en la comunidad open source.

Veamos todos:

Rank	Language	Pull Requests
1	JavaScript	2.3M
2	Python	1M
3	Java	986K
4	Ruby	870K
5	PHP	559K
6	C++	413K
7	CSS	335K
8	C#	326K
9	Go	285K
10	C	239K
11	TypeScript	207K
12	Shell	206K
13	Swift	107K
14	Scala	99K
15	Objective C	66K

Como dice el articulo: "De la lista anterior, podemos inferir que JavaScript es el lenguaje más utilizado entre los desarrolladores de todo el mundo, seguido por Python. GitHub mencionó que Python reemplazó a Java como el segundo idioma más popular en su plataforma, con un 40 por ciento más de solicitudes de extracción abiertas este año que el pasado."

GitHub también ha compartido algunos puntos de vista sobre la mayoría de las organizaciones y proyectos activos por la cantidad de colaboradores únicos, forks y comentarios. Y aquí están los datos sobre ellos.

Un vistazo a los datos anuales de GitHub:

• 24 millones de usuarios totales
• 1,5 millones de organizaciones
• 67 millones de depósitos totales
• 1 mil millones de compromisos públicos desde septiembre de 2016
• 25,3 millones de depósitos activos desde septiembre de 2016
• 1,3 millones de nuevas solicitudes desde septiembre de 2016

Dejo el articulo: https://curiouspost.com/list-15-popular-programming-languages-used-coders-github/

Juego de Serie en c++

Cuando quiero aprender un nuevo lenguaje desarrollo un juego de series, es decir aparece una serie con un valor faltante y el jugador debe completarlo.

Uno de los requerimientos no funcionales es que se pueda agregar una serie nueva fácilmente, para cumplirlo vamos a utilizar las ventajas de herencia y polimorfismo.

Vamos a desarrollar este juego en C++:

Empecemos desarrollo de la serie, la serie tiene como responsabilidad generarse y si lo hacemos de esta manera podemos utilizar la potencia del polimorfismo, para que no quede acoplado la generación de la serie con el desarrollo del juego:

Vamos a dividir nuestros archivos en .h y .cpp empecemos con secuencia.h :

#ifndef SECUENCIA_H
#define SECUENCIA_H

class Secuencia
{
protected:
    int valores[4];
public:
    Secuencia();
    virtual void generarValores()=0;
    int getValor(int index);
};

#endif // SECUENCIA_H

secuencia.cpp :

#include "secuencia.h"

Secuencia::Secuencia()

{

    for(int i=0;i<4; i++){

        valores[i]=0;

    }

}

int Secuencia::getValor(int index){

    return valores[index];

}

Ahora vamos a ver las implementaciones de secuencia, veamos secuenciapar.h :

#ifndef SECUENCIAPAR_H

#define SECUENCIAPAR_H

#include "secuencia.h"

class SecuenciaPar:public Secuencia

{

public:

    SecuenciaPar();

    void generarValores();

};

#endif // SECUENCIAPAR_H

secuenciapar.cpp :

#include "secuenciapar.h"

#include <stdlib.h>

#include <time.h>

SecuenciaPar::SecuenciaPar()

{

}

void SecuenciaPar::generarValores(){

    srand(time(NULL));

    int par = (rand() % 100) * 2;

    srand(time(NULL));

    int par2 = (rand() % 50) * 2;

    for(int i = 0; i<4; i++){

        valores[i] = par + (par2 * i);

    }

}

secuenciaimpar.h :

#ifndef SECUENCIAIMPAR_H

#define SECUENCIAIMPAR_H

#include "secuencia.h"

class SecuenciaImpar:public Secuencia

{

public:

    SecuenciaImpar();

    void generarValores();

};

#endif // SECUENCIAIMPAR_H

secuenciaimpar.cpp :

#include "secuenciaimpar.h"

#include <stdlib.h>

#include <time.h>

SecuenciaImpar::SecuenciaImpar()

{

}

void SecuenciaImpar::generarValores(){

    srand(time(NULL));

    int par = ((rand() % 100) * 2)+1;

    srand(time(NULL));

    int par2 = ((rand() % 50) * 2);

    for(int i = 0; i<4; i++){

        valores[i] = par + (par2 * i);

    }

}

Ahora vamos a ver el juego, este tiene la responsabilidad de verificar si el usuario acertó y tambien debe llevar los puntos: 

#ifndef JUEGO_H

#define JUEGO_H

#include "secuencia.h"

class Juego

{

private:

    int puntos;

    Secuencia * secuencia;

    void regenerar();

public:

    Juego();

    int getValor0();

    int getValor1();

    int getValor3();

    bool validar(int numero);

    int getPuntos();

};

#endif // JUEGO_H

juego.cpp :

#include "juego.h"

#include "secuenciapar.h"

#include "secuenciaimpar.h"

#include <stdlib.h>

#include <time.h>

Juego::Juego()

{

    secuencia = 0;

    this->puntos = 0;

    this->regenerar();

}

void Juego::regenerar() {

    if (secuencia != 0) delete secuencia;

    srand(time(NULL));

    int aleatorio = (rand() % 2);

    switch (aleatorio) {

    case 0:

        secuencia = new SecuenciaPar();

        break;

    default:

        secuencia = new SecuenciaImpar();

        break;

    }

    secuencia->generarValores();

}

int Juego::getValor0(){

    return this->secuencia->getValor(0);

}

int Juego::getValor1(){

    return this->secuencia->getValor(1);

}

int Juego::getValor3(){

    return this->secuencia->getValor(3);

}

bool Juego::validar(int numero) {

    bool resultado = false;

    if (numero == this->secuencia->getValor(2)) {

        this->puntos++;

        resultado = true;

    } else {

        this->puntos--;

    }

    this->regenerar();

    return resultado;

}

int Juego::getPuntos(){

    return this->puntos;

}

Ahora programemos la interfaz en este caso utilizaremos la consola:

#include <iostream>

#include <stdlib.h>

#include "juego.h"

using namespace std;

int main()

{

    Juego juego;

    cout << " ========== BIENVENIDO =========== "<<endl;

    cout << endl;

    while (true) {

        cout << " La secuencia es : "<<endl;

        cout << "                    " << juego.getValor0() << "   " ;

        cout << juego.getValor1() << "   ?   " << juego.getValor3()<<endl;

        int valor = 0;

        cout << "                               ";

        cin >> valor;

        if  (juego.validar(valor)) {

            cout << "     Ganaste!!  :D "<< endl;

        } else {

            cout << "     Perdiste   :(  "<< endl;

        }

        cout << endl << "     Sus puntos son :  " << juego.getPuntos() << endl;

        cout << "     Desea continuar jugando ? (y/n)  ";

        char opt;

        cin >> opt;

        if (opt == 'n') return 0;

           else cout << endl << endl;

    }

}

Y eso es todo a jugar se a dicho!!

Dejo el repositorio git: https://github.com/emanuelpeg/SerieCpp

Juego de Serie en Scala

Cuando quiero aprender un nuevo lenguaje desarrollo un juego de series, es decir aparece una serie con un valor faltante y el jugador debe completarlo.

Uno de los requerimientos no funcionales es que se pueda agregar una serie nueva fácilmente, para cumplirlo vamos a utilizar las ventajas de herencia y polimorfismo.

Vamos a desarrollar este juego en scala:

Empecemos desarrollo de la serie, la serie tiene como responsabilidad generarse y si lo hacemos de esta manera podemos utilizar la potencia del polimorfismo, para que no quede acoplado la generación de la serie con el desarrollo del juego:

package com.blog.serie

import scala.util.Random

abstract class Serie {

  var semilla = Random.nextInt(2000) + 1;

  def generate(): Seq[Int];

  val serie : Seq[Int]= generate();

}

Luego implementemos las series:

package com.blog.model.serie

import scala.util.Random

/**
 * @author emanuel
 *
 */
class SeriePar extends Serie {

  override def generate(): Seq[Int] = for(i <- 0 to 3) yield (i + semilla) * 2

}

Una serie impar:

package com.blog.model.serie

import scala.util.Random
import scala.collection.immutable.List

/**
 * @author emanuel
 *
 */
class SerieImpar extends Serie {

  override def generate(): Seq[Int] =
    for(i <- 0 to 3) yield if ((semilla%2)==0) (i * 2) + semilla + 1 else (i * 2) + semilla

}

Serie normal

package com.blog.model.serie

import scala.util.Random

class SerieNormal extends Serie {

  override def generate(): Seq[Int] = for(i <- 0 to 3) yield (i + semilla)

}

Serie de fibonacci;

package com.blog.model.serie

import scala.util.Random

/**
 * @author emanuel
 *
 */
class SerieFibonacci extends Serie {

 override def generate(): Seq[Int] =  {
   semilla = Random.nextInt(20) + 1
 
   def fibo(n:Int) : Int = n match {
     case 0 => 1
     case 1 => 1
     case _ => fibo(n-1) + fibo(n-2)
   }
 
   for(i <- 0 to 3) yield fibo(i + semilla)
 }

}

Ya tenemos un conjunto interesante de series, ahora a programar el juego:

package com.blog.model

import com.blog.model.serie._
import scala.util.Random

class Juego {

  var serie : Serie = null
  var puntos = 0

  def generarSerie():Unit = {
    val selector = Random.nextInt(4);
 
    selector match {
      case 0 => serie = new SerieNormal()
      case 1 => serie = new SeriePar()
      case 2 => serie = new SerieFibonacci()
      case _ => serie = new SerieImpar()
    }
  }

  generarSerie()

  def getValor0() = serie.serie.seq(0)
  def getValor1() = serie.serie.seq(1)
  def getValor3() = serie.serie.seq(3)

  def isValid(i: Int):Boolean =
    if (i == serie.serie.seq(2)) {
       puntos= puntos+1
       generarSerie()
       true
    } else {
      generarSerie()
      false
    }

}

El Juego es el encargado de crear la serie, mostrar los valores y validar si la respuesta es correcta. Ahora programemos la interfaz en este caso utilizaremos la consola:

package com.blog.model


object Principal extends App {

  var juego = new Juego
  var op = "ok"

  while (op == "ok") {

    println("Serie " + juego.getValor0() + " , "+ juego.getValor1() + " ___ " + juego.getValor3())
    println()
    print(" Indique el valor faltante : ")
    val i = readInt()
 
    if (juego.isValid(i)) {
      println(" Ganaste !! Puntaje : " + juego.puntos)
    } else {
      println(" Perdiste !! Puntaje : " + juego.puntos)
    }
 
    println(" Si desea continuar ingrese ok : ")
    op = readLine()

  }

  println(" chau !! ")

}

Y eso es todo a jugar se a dicho!!

Dejo el repositorio git: https://github.com/emanuelpeg/serieScala

Mantenlo Simple estupido

Se ha hablado mucho del principio Kiss (Keep it simple, Stupid!), el cual es un principio que toma como estandarte la simplicidad. El código debe ser simple y debemos priorizar el entendimiento, porque luego si tenemos que mantenerlo debemos entenderlo (que no es poco)

Muchas veces se toma este principio como una escusa para tomar el camino más fácil (que no es el más simple) para dar un ejemplo el encapsulamiento no es algo fácil, nos genera un trabajo extra acceder a los atributos solo a través de método, pero esto es simple. Nos libera de la responsabilidad de saber la estructura de los objeto o porque se guardo de una manera y no de otra, debo saber que puedo modificar y que no, etc. Por lo tanto el encapsulamiento genera un mayor trabajo pero por lejos es el camino más simple, no debo conocer la estructura interna de mi objeto, solo lo debo usar.

Se trata de hacerlo todo sencillo y simple. No debemos entender sencillo como falta de elaboración o falta de horas de dedicación a la acción en sí, sino que lo simple es algo de una sencillez tal que el esfuerzo psicológico / mental por el receptor es mínimo. Esto conlleva a un aumento (por parte de los consumidores para con la marca) de:

• Aceptación.
• Asimilación.
• Comprensión.
• Recuerdo

Por lo tanto no uses kiss como una excusa para no esforzarte. Debemos buscar entre cientos de diseños y elegir el que de modo más simple represente mejor la realidad.

Cursos online gratuitos que inician en octubre 2017

Para todos los que les interese empezar un curso online, les dejo una buena lista:


Introducción a la programación orientada a objetos en Java
Impartido por: Universidad de los Andes
Plataforma: Coursera
Enlace: Ir al curso

¡A Programar! Una introducción a la programación
Impartido por: Universidad ORT Uruguay
Plataforma: Coursera
Enlace: Ir al curso

Introducción a la programación en Python I
Impartido por: Pontificia Universidad Católica de Chile
Plataforma: Coursera
Enlace: Ir al curso

La Web Semántica
Impartido por: Pontificia Universidad Católica de Chile
Plataforma: Coursera
Enlace: Ir al curso

Detección de objetos
Impartido por: Universitat Autònoma de Barcelona
Plataforma: Coursera
Enlace: Ir al curso

Ludificación
Impartido por: Universidad de Pensilvania
Plataforma: Coursera
Enlace: Ir al curso

Sistemas Digitales: De las puertas lógicas al procesador
Impartido por: Universitat Autònoma de Barcelona
Plataforma: Coursera
Enlace: Ir al curso

Introducción a Data Science: Programación Estadística con R
Impartido por: Universidad Nacional Autónoma de México
Plataforma: Coursera
Enlace: Ir al curso

Arduino y algunas aplicaciones
Impartido por: Universidad Nacional Autónoma de México
Plataforma: Coursera
Enlace: Ir al curso

Excel
Impartido por: Universidad Politécnica de Valencia
Plataforma: edX
Enlace: Ir al curso

Excel 2: Gestión de datos
Impartido por: Universidad Politécnica de Valencia
Plataforma: edX
Enlace: Ir al curso

Diseña presentaciones eficaces con Powerpoint
Impartido por: Universidad Politécnica de Valencia
Plataforma: edX
Enlace: Ir al curso

Android: Introducción a la Programación
Impartido por: Universidad Politécnica de Valencia
Plataforma: edX
Enlace: Ir al curso

Swift 4 fue liberado

Este post llega muy tarde pero llego! Swift 4 fue liberado (hace rato)

Esta versión contiene muchos cambios y actualizaciones del lenguaje y la biblioteca estándar, especialmente las nuevas funciones de String, las colecciones extendidas, archivo y la serialización, entre otros.

En Swift 4 las cadenas son colecciones propiamente dichas por lo cual son directamente iterable y proporciona todos los métodos de las colecciones y las secuencias, por ejemplo:

for c in myString {
  print(c)
}
myString.filter { c in
  return boolCheck(c)
}
let l = myString.count
let myString2 = myString.dropFirst()

Otra nueva característica es que ahora los string soportan Unicode 9 and literales multi-lineas.

Swift 4 también mejora la forma en que puedes crear, usar y administrar tipos de colecciones, como Dictionary y Set.

En primer lugar, ahora puede crear un diccionario a partir de una secuencia de tuplas, así como especificar cómo manejar los duplicados, si los hay, tanto al crear un diccionario como al fusionar dos diccionarios:

let items = ["ItemA", "ItemB", "ItemC", "ItemA"]
let prices = [14.40, 41.63, 3.71, 15.63]
let catalog1 = Dictionary(uniqueKeysWithValues: zip(items, prices))
let catalog2 = Dictionary(prices, uniquingKeysWith: { (l, r) in
    l })
let catalog3 = Dictionary(prices, uniquingKeysWith: { (l, r) in
    l + r })
let merged = catalog.merge(catalog3) { (l, r) in r }

Dictionary y Set ahora se puede filtrar en otro  tipo, en lugar de en un Array. Además, los diccionarios soportan un nuevo método mapValues:

let catalog4 = catalog.filter { $0.value < 15.0 }
let catalog5 = catalog.mapValues { $0 * 1.2 }

Otra característica útil en los diccionarios es la posibilidad de especificar un valor predeterminado al acceder a sus elementos:

let price1 : Float = catalog['none', default: 0.0]
let price2 : Float? = catalog['none']

Swift 4 añade serialización a todos los tipos a través del protocolo Codable. Por ejemplo:

struct Card: Codable, Equatable {
    enum Suit: String, Codable {
        case clubs, spades, hearts, diamonds
    }

    enum Rank: Int, Codable {
        case two = 2, three, four, five, six, seven, eight, nine, ten, jack, queen, king, ace
    }

    var suit: Suit
    var rank: Rank

    static func ==(lhs: Card, rhs: Card) -> Bool {
        return lhs.suit == rhs.suit && lhs.rank == rhs.rank
    }
}
let hand = [Card(suit: .clubs, rank: .ace), Card(suit: .hearts, rank: .queen)]

Por ultimo, Swift 4 tiene dos modos, seleccionados a través de la opción -swift-version compiler. En el modo Swift 3.2, el compilador aceptará la mayoría de fuentes compatibles con los compiladores Swift 3.x. En este modo, la mayoría de las características del lenguaje Swift 4 estarán disponibles, pero las actualizaciones de las API existentes anteriormente no. En el modo Swift 4.0, obtendrá acceso a todas las funciones de Swift 4, a expensas de algunos cambios de origen, que como de costumbre pueden manejarse utilizando el asistente de migración de Xcode.

Ojo!! Hay mucho más para Swift 4.

Dejo link:
https://www.infoq.com/news/2017/09/swift-4-official-release
https://swift.org