domingo, 28 de septiembre de 2014

sábado, 27 de septiembre de 2014

PureScript, un lenguaje que lleva la programación funcional al browser

PureScript es un lenguaje similar a Haskell que compila a javascript, por lo que puede ser ejecutado por un browser y interactuar con una pagina web.


PureScript fue creado por Phil Freeman, quien se inspiro en Haskell para hacer este lenguaje. El cual nos trae de Haskell las siguientes características:

  • Inferencia de tipos.
  • Higher Kinded Polymorphism, no supe como traducirlo, pero sería un mecanismo de abstracción sobre constructores.
  • Pattern matching
  • Type Classes: tan poco me conversia la traducción, un mecanismo de abstracción sobre las estructuras de datos que permite utilizarlos sin tener que pensar directamente en la estructura de los datos en sí.
El código esta en github y es de licencia MIT.

Dejo link:

miércoles, 24 de septiembre de 2014

Soporte nativo para Json en java 9?

Al parecer en Java 9 vamos a tener soporte nativo para JSon. Es decir que vamos a poder utilizar una Api nativa para procesar Json.

 Históricamente, Java ha sido una plataforma de elección para el procesamiento de XML, pero en los últimos años el mundo se ha movido más y más hacia los datos JSON siendo consumida y devuelta por los servicios web basados ​​en REST simples. Java ha bajado un poco detrás de la curva de otros lenguajes, y es este déficit que JEP 198 espera abordar.

Dejo link: http://www.infoq.com/news/2014/09/CoreJSONJava9

domingo, 21 de septiembre de 2014

Primeros pasos en Qt: Qt Designer


Qt designer es una herramienta pensada para el diseño de interfaces de forma cómoda y fácil.

Una de las ventajas de la utilización de Qt Designer es que permite a los programadores una gran libertad para modificar sus diseños sin ser forzados a cambiar su código fuente. Al desarrollar escribiendo solo código C++, los cambios en el diseño pueden llevar mucho tiempo. Con Qt Designer, no se pierde tiempo, simplemente regenera el código fuente que ha cambiado.
Las Interfaz de usuario (ventanas) se guarda en un archivo .ui (un formato de archivo basado en XML), mientras que la funcionalidad personalizada se implementa mediante subclases.

Supongamos que debamos acceder a cualquier componente que hemos diseñado desde el diseñar. Debemos llamarlos desde un objeto generado, que se construye en el constructor y es de igual tipo que la ventana, no estoy siendo muy claro, veamos un poco de código para expresarme mejor:

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);
}

MainWindow::~MainWindow()
{
    delete ui;
}

void MainWindow::on_pushButton_clicked()
{
    ui->pushButton->setText("Chau!!");
}

En el ejemplo para acceder a pushButton tuvimos que utilizar el objeto ui que es la ventana.


Aprendiendo Ruby on Rails 4.0

Sin preámbulos, quiero compartir el libro con ustedes, si bien el libro no esta terminado es totalmente gratuito y en español. Por lo tanto suscribanse!!

Dejo un extracto:

"Conoce como desarrollar aplicaciones web con un enfoque de afuera hacia adentro - Outside-in - con el marco de trabajo de Ruby on Rails 4.0.

Aprender de la naturalidad de un languaje de programación como Ruby y de cómo Ruby on Rails 4.0 explota nuestra productividad."

Dejo link:
http://railsenespanol.co/


jueves, 18 de septiembre de 2014

10 Free Books for Learning JavaScript



Quiero compartir un buen post sobre Javascript y como es la mejor manera de aprenderlo.

Dejo el link:
http://codecondo.com/free-javascript-books

domingo, 14 de septiembre de 2014

Primeros pasos en Qt: Signals y Slots a fondo

El mecanismo de signals y slots es fundamental para qt. Los Slots son muy similares a las funciones comunes, pueden ser virtuales, sobrecargados, privados, protegidos y públicos. Además pueden ser invocados como cualquier otra función de c++ y sus parámetros pueden ser de cualquier tipo. La diferencia con las funciones es que los Slots pueden ser invocados automáticamente desde una señal.

La conexión entre signal y slot es así:

connect(sender, SIGNAL(signal), receiver, SLOT(slot));

Donde sender y receiver son objetos de tipo QObjects, además signal y slot se pasan como parámetro sin parámetros, solo el nombre de la función.

Una signal puede llamar a diferentes slots y un slot puede ser llamado por diferentes funciones. Veamos unos ejemplos:

Una signal puede llamar a diferentes slots:

connect(slider, SIGNAL(valueChanged(int)), spinBox, SLOT(setValue(int)));
connect(slider, SIGNAL(valueChanged(int)), this, SLOT(updateStatusBarIndicator(int)));

Un slot es llamado por diferentes signal: 
connect(lcd, SIGNAL(overflow()), this, SLOT(handleMathError()));
connect(calculator, SIGNAL(divisionByZero()), this, SLOT(handleMathError()));

Una signal puede conectar otra signal:
connect(lineEdit, SIGNAL(textChanged(const QString &)), this, SIGNAL(updateRecord(const QString &)));
Cuando la primera señal es emitida, la segunda es emitida.

Una conexión puede ser removida: 
disconnect(lcd, SIGNAL(overflow()), this, SLOT(handleMathError()));

Algo muy importante es que la signal y el slot o signal a la que es conectada debe tener la misma cantidad de parámetros y del mismo tipo. Si el slot o signal a la que es conectada tiene más parámetros, simplemente sera ignorados. Si los parámetros son de diferente tipo qt lanzara una advertencia cuando se compila y un error en tiempo de ejecución.

El mecanismo de signals y slots, no esta limitado a el diseño de interfaces de usuarios, también se puede usar en el modelado heredando de QObject.

sábado, 13 de septiembre de 2014

Linux for Hank

Quiero compartir este video que habla de la historia de un usuario que desea mejorar su vida  y elige el mejor sistema operativo de la historia:

jueves, 11 de septiembre de 2014

Que lenguaje debo aprender??

Siempre que se desea aprender un lenguaje se debe saber si se utiliza y donde, les dejo una gráfica que esta buena. La encontré en la web, no es de mi autoria pero en linea general esta bien.



Ojo donde dice scale es scala...

miércoles, 10 de septiembre de 2014

Curso básico de Less


Less es a css lo que PHP a html...

Una reflexión antes de sugerirles este curso que dicta la empresa DevCode; según ellos:

"En el curso básico de Less aprenderás a trabajar las hojas de estilo con funcionalidades de un lenguaje de programación para el desarrollo Frontend. Después de hacer este curso no podrás escribir CSS sin él preprocesador."

Les dejo el link:
http://devcode.la/cursos/curso-basico-de-less/?utm_source=googleplus&utm_medium=img&utm_campaign=imgLes0less01


martes, 9 de septiembre de 2014

Active records vs DAO



Cuando debemos almacenar datos nos surge la duda existencial donde meto los métodos que guardan los datos? Para resolver este problema existen 2 patrones muy utilizados:

Active record o registros activos es un patrón que dice que el objeto es encargado de auto guardarse, cosa que no es muy lógica pero es así. Este patrón tiene varias desventajas, la más importante es que el modelo queda "sucio" con el modo de almacenar los datos. Este es el patrón que utiliza rails para acceder a base de datos.

DAO, o objeto para acceso de datos (la traducción se debería checkear) Este patrón indica que el objeto no tiene la responsabilidad de guardarse, sino que existe otro objeto que es encargado de guardar, y recuperar datos. Este patrón es más flexible y abstrae a los objetos del modo y donde se guarden.

Obviamente que no todos los problemas son iguales, por lo tanto cada patrón tiene su punto fuerte, si la idea es hacer algo flexible que abstraiga del modo de guardarse, el patrón DAO es el mejor (y mi preferido). Ahora bien la aplicación es pequeña y no existe necesidad de cambiar el almacén de datos. active record puede ser una solución.

lunes, 8 de septiembre de 2014

Aprendiendo Clojure


Solo quiero hacerme eco de una publicación de java México sobre un tutorial de Clojure. Es una lectura muy fácil y entretenida. Más que nada para entender de que se trata este lenguaje.

Dejo link:
http://www.javamexico.org/blogs/sr_negativo/aprendiendo_clojure

domingo, 7 de septiembre de 2014

Run Swift



Quiero compartir con ustedes una pagina donde van a poder probar de forma online el nuevo lenguaje de Applet, Swift. 

Dejo link:

sábado, 6 de septiembre de 2014

Primeros pasos en Qt: Creación de diálogos

Ahora vamos a ver como crear ventanas de diálogos con Qt. En este ejemplo vamos a programar una ventana de búsqueda. Las ventanas de diálogos le permiten al usuario definir una configuración o definir una acción. Además crearemos este dialogo de dos formas diferentes, una con solo código y la otra utilizando en diseñador de interfaces de Qt.

El código fuente se encontrará en 2 archivos finddialog.h y finddialog.cpp. Veamos finddialog.h:

#ifndef FINDDIALOG_H
#define FINDDIALOG_H
#include <QDialog>
class QCheckBox;
class QLabel;
class QLineEdit;
class QPushButton;

En la primera parte incluimos QDialog, clase que vamos a extender y definimos los componentes que vamos a utilizar.

class FindDialog : public QDialog
{
Q_OBJECT
public:
FindDialog(QWidget *parent = 0);

Q_OBJECT es una macro que es necesario agregar para que Qt incluya nuestro componente y nos permita utilizar SIGNAL y SLOT. Además extendemos de QDialog que a la vez extiende de QWidget. También definimos un constructor que permite asignar un componente contenedor, por defecto este puntero es nulo.

signals:
void findNext(const QString &str, Qt::CaseSensitivity cs);
void findPrevious(const QString &str, Qt::CaseSensitivity cs);

Con la palabra clave signals indicamos las señales de nuestro componente, en este caso definimos dos. Estas señales van a ser emitidas cuando el usuario presione el botón de buscar.

La palabra clave signals, también es una macro. El compilador en la etapa de preprocesamiento utiliza estas palabras claves para introducir código y transforma nuestro código en C++ estándar, aumentando nuestra producción y ahorrándonos escribir código repetitivo.

private slots:
void findClicked();
void enableFindButton(const QString &text);

private:
QLabel *label;
QLineEdit *lineEdit;
QCheckBox *caseCheckBox;
QCheckBox *backwardCheckBox;
QPushButton *findButton;
QPushButton *closeButton;
};

#endif

En la sección private slot declaramos 2 slots. Para implementar estos slots es necesario acceder a los componentes que son contenidos por el dialogo, por lo que debemos mantener punteros a los mismos. Slot es una palabra clave similar a signal y que es una extensión del lenguaje a través de macros.

Ahora vamos a ver finddialog.cpp:

#include <QtGui>
#include "finddialog.h"

Primero, nosotros incluimos <QtGui> este archivo es un archivo de cabecera que contiene todas las definiciones de los componentes visuales de Qt. Qt esta formado por diferentes módulos, los módulos más importantes son: QtCore, QtGui, QtNetwork, QtOpenGL, QtSql, QtSvg y QtXml. El archivo <QtGui> contiene las definiciones de los módulos QtCore y QtGui.

En el archivo de cabecera finddialog.h solo incluimos <QDialog> y luego utilizamos declaraciones de QCheckBox, QLabel, QLineEdit y QPushButton, tal vez simplemente podríamos haber incluido <QtGui>. Sin embargo, en general no es buena práctica incluir un archivo de cabecera tan grande de otro archivo de cabecera.

FindDialog::FindDialog(QWidget *parent) : QDialog(parent)
{
label = new QLabel(tr("Find &what:"));
lineEdit = new QLineEdit;
label->setBuddy(lineEdit);
caseCheckBox = new QCheckBox(tr("Match &case"));
backwardCheckBox = new QCheckBox(tr("Search &backward"));
findButton = new QPushButton(tr("&Find"));
findButton->setDefault(true);
findButton->setEnabled(false);
closeButton = new QPushButton(tr("Close"));

En el constructor nos encargamos de crear los diferentes componentes. La función tr es una función que esta declarada en QObject y se utiliza para que la aplicación se pueda traducir fácilmente. Con '&’ indicamos el shortcut que permite lanzar la funcionalidad. Por ultimo indicamos el botón por defecto, es la acción que se va a llamar si se presiona enter.

Luego, conectamos los eventos o señales con funcionalidad que debe ejecutarse:

connect(lineEdit, SIGNAL(textChanged(const QString &)), this, SLOT(enableFindButton(const QString &)));
connect(findButton, SIGNAL(clicked()), this, SLOT(findClicked()));
connect(closeButton, SIGNAL(clicked()), this, SLOT(close()));

Como se puede ver si cambia el texto de lineEdit se ejecutara la función enableFindButton, y a la vez si se ejecuta clicked de findButton y closeButton se ejecutara la función asignada. Dado que nuestro dialogo de busqueda es un QObject, no necesitamos llamar a la función connect con el prefijo QObject:: por ultimo organizamos la aplicación con layouts y agregamos el titulo de nuestra ventana:

QHBoxLayout *topLeftLayout = new QHBoxLayout;
topLeftLayout->addWidget(label);
topLeftLayout->addWidget(lineEdit);

QVBoxLayout *leftLayout = new QVBoxLayout;
leftLayout->addLayout(topLeftLayout);
leftLayout->addWidget(caseCheckBox);
leftLayout->addWidget(backwardCheckBox);

QVBoxLayout *rightLayout = new QVBoxLayout;
rightLayout->addWidget(findButton);
rightLayout->addWidget(closeButton);
rightLayout->addStretch();

QHBoxLayout *mainLayout = new QHBoxLayout;
mainLayout->addLayout(leftLayout);
mainLayout->addLayout(rightLayout);
setLayout(mainLayout);
setWindowTitle(tr("Find"));
setFixedHeight(sizeHint().height());
}

Ahora debemos programar las señales:

void FindDialog::findClicked()
{
QString text = lineEdit->text();
Qt::CaseSensitivity cs =
caseCheckBox->isChecked() ? Qt::CaseSensitive : Qt::CaseInsensitive;
if (backwardCheckBox->isChecked()) {
    emit findPrevious(text, cs);
} else {
    emit findNext(text, cs);
}
}

void FindDialog::enableFindButton(const QString &text)
{
findButton->setEnabled(!text.isEmpty());
}

findClicked() es un Slot que se llama cuando presionamos el botón findButton y este método llama a la función  findPrevious o findNext dependiendo si backwardCheckBox fue checkeado. La palabra clave emit no es estándar de C++, es utilizada por Qt y por macros se transforma a C++ estándar.  Con emit se lanzaran las señales  findNext o  findPrevious.

enableFindButton() es llamado cuando se cambia el texto cambia y activa el botón findButton.

Veamos main.cpp:

#include <QApplication>
#include "finddialog.h"

int main(int argc, char *argv[])
{
QApplication app(argc, argv);
FindDialog *dialog = new FindDialog;
dialog->show();
return app.exec();
}

Si probamos nuestra ventana de dialogo, vamos a ver que no busca en ningún lado y eso porque solo lanza las señales  findPrevious y findNext pero ningún objeto intercepta estas señales y hace algo con ellas. Más adelante vamos a utilizar este dialogo...


Decorators en python


Supongamos que queremos logear cada vez que se llama una función. Es decir queremos saber cada vez que se llame una función. Para esta tarea podemos utilizar los decorators, no confundir con el patrón decorator.

Los decorators nos permiten agregar funcionalidad a una función (valga la redundancia)

Lo primero que debemos tener en cuenta es que vamos a trabaja con un closure. Este concepto hace referencia  a que una función puede ser evaluada en un contexto que puede, a su vez, uno o más componente dependiendo que otro entorno diferente. En nuestro caso, tendremos una función declarada dentro de otra, devolviendo la principal el resultado de la ejecución de la función contenida en la misma. Aunque parece un poco confuso, es mejor entenderlo echando un vistazo al siguiente código:

def principal(f) :
      def nueva():
          print("ini", f.__name__)
          f()
          print("fin", f.__name__)
      return nueva

El siguiente paso es definir una nueva función a la que llamaremos decorada. Será esta mueva función a la que aplicaremos como decorador la función principal:

@principal
def decorada():
     print("decorada")

Ahora llamamos la función y observamos la salida:

decorada()
ini decorada
decorada
fin decorada

De esta forma podemos utilizar decorators para agregar funcionalidad a funciones. Lo que sucede es que la función principal es llamada con la función decorada como parámetro, y principal devuelve la función nueva que internamente llama a decorada. :P

uff, mucho más fácil escribir el código que explicarlo...


jueves, 4 de septiembre de 2014

Lambda Architecture


Siempre trato de postear noticias del mundo funcional, pero esta vez me sorprendí. Dado que no tenia idea sobre el estilo arquitectura lamdba. 

La arquitectura Lambda es un enfoque para la creación de aplicaciones de procesamiento de flujo utilizando Apache Hadoop and Apache Storm o sistemas similares.

Dejo un link para empezar a leer:

Lo malo de python: Name mangling


Estoy leyendo un poco sobre Python y la verdad me parece bastante horrendo la forma en que implementa la programación orientada a objeto.

Respeto mucho las diferentes formas de pensar pero a mi forma de ver la programación la herencia multiple tiene más desventajas que ventajas y Python utiliza esta técnica.

Otro punto que no me parece beneficioso es el name mangling, esta técnica es una técnica utilizada para resolver diversos problemas causados ​​por la necesidad de tener nombres únicos para las entidades de programación en muchos lenguajes de programación modernos.

Python transforma los nombres que comienzan con doble guion bajo en nombres de la clase más el nombre del método:

class Test(object):
    def __mangled_name(self):
        print("hola")
    def normal_name(self):
        pass

print dir(Test)

a:

['_Test__mangled_name',
'__doc__',
'__module__',
'normal_name']

Esto lo hace para que el método sea privado, y no se pueda acceder, pero en realidad se puede acceder con otro nombre.

>>> t = Test()
>>> t.__mangled_name()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Test' object has no attribute '__mangled_name'
>>> t._Test__mangled_name()
hola

Por lo tanto los métodos privados son un espejismo :(