miércoles, 31 de diciembre de 2014

Libros leído durante el 2014


Este año leí 12 libros y medio...


  1. Niños del Hombre, PD James
  2. Vuelve el Pasado, Kristi Hannah
  3. La quinta misteriosa, Doroty Gilman
  4. The Blessed, Tonya Hurley. El peor libro que leído en años.
  5. Divergente. Veronica Roth.
  6. Los Juegos del Hambre. Suzane Collins.
  7. El Juego de Ender. Orson Scott Card.
  8. Farenheit 451. Rad Bradbury.
  9. Battle Royale. Houshun Takami
  10. La Sombra del Hegemón. Orson Scott Card
  11. La Divina Comedia, Dante Alighieri.
  12. Insurgente, Veronica Roth.



Desde Mi Cielo, Alice Sebold (Incompleto aun...)

Feliz 2015.

jueves, 4 de diciembre de 2014

SOAP vs REST



Hay gente que dice que REST no es un webservice y que los JSON's son cosas muy limitadas para intercambiar datos con el cliente...




miércoles, 3 de diciembre de 2014

miércoles, 1 de octubre de 2014

Me cae fine

martes, 23 de septiembre de 2014

Cambiar credenciales de acceso en TortoiseSVN

Me encontré esto en stackoverflow y pienso que puede ser de utilidad:

In TortiseSVN settings (found via the right-click menu), open the Saved Data tab, and clear out the Authentication Data. The side effect is that it clears out all authentication data, and you will have to re-enter your own username/password.


domingo, 7 de septiembre de 2014

Como crear un proyecto en Ext.NET MVC 5 en Visual Studio 2013

Como mencionaba en post anteriores actualmente me encuentro desarrollando en la plataforma .NET con el framework Ext.NET MVC. En este post hablaré acerca de como crear un proyecto.
Lo primero que hay que hacer es crear un proyecto en Visual Studio:


El proyecto debe ser Aplicación Web Asp.Net MVC *. Por defecto en mi VS viene el MVC4 pero no importa ya que lo actualizaremos a MVC 5 porque la ultima versión de ExtNet que hay trabaja con MVC5. Damos click en aceptar y en la siguiente pantalla seleccionamos "Aplicación de Internet" y seleccionamos "Razor" en donde dice "Motor de Vistas".


Damos click en aceptar y enseguida se creará el proyecto en VS. Una vez creado ustedes pueden ejecutar el proyecto dando click en el botón de play o presionando la tecla F5. Enseguida  les mostrará la siguiente pantalla por default.






Pero aun no hemos instalado ExtNET. Para instalarlo primero actualizaremos el MVC a su versión 5.
Para eso abrimos la consola del administrador de paquetes, para eso primero entramos en el menú herramientas y en la opción de "Administrador de paquetes nuget" seleccionamos "Consola del administrador de paquetes". No olviden detener el proyecto cada vez que instalen un paquete por medio de la consola.








Una vez abierta la consola escribimos lo siguiente:

Install-Package Microsoft.AspNet.Mvc 

Y con eso se actualizará a su versión 5 la libreria MVC.Después, procederemos a instalar ExtNet escribiendo lo siguiente en la consola:





Install-Package Ext.NET.MVC









Después de llevar a cabo las instalaciones es posible correr el proyecto. Debería correr bien pero es muy probable que les muestre el siguiente error:




Lo que deben hacer es actualizar la librería de webhelpers mediante la consola:


Install-Package Microsoft.AspNet.WebHelpers

Debería funcionar bien, pero puede que salga el siguiente error:


Parar "reparar" dicho error instalamos en la consola lo siguiente:


Install-Package Microsoft.AspNet.WebPages.Data




Ya  de esta manera no debería haber errores, entonces aparece está página:



Haste este momento solo hemos instalado las librerías pero no hay manera de comprobar que Ext.NET está funcionando correctamente. Para comprobar que Ex.NET está funcionando debemos hacer un pequeño cambio en el archivo RouteConfig que está dentro de la carpeta App_Start de nuestro proyecto:





Dentro del RouteConfig.cs hay una línea que tiene lo siguiente:

defaults: new { controller = "Home", action = "Index", id = UrlParameter.Optional 

Lo que vamos a hacer es revisar en nuestra carpeta "Controllers" el nombre del controlador de muestra que se instala por defecto junto con ExtNet el cual en mi caso se llama ExtNetController.cs.



Como ven, la línea que anterior mencione queda asi:

defaults: new { controller = "ExtNet", action = "Index", id = UrlParameter.Optional }

El nombre del controlador lo cambié a ExtNet con lo que le digo a VS que cuando el projecto se ejecute lo primero que tiene que ejecutar es el método Index del controllador ExtNet. Si se fijan dentro del controlador ExtNet este ya tiene un método Index el cual renderea la vista Index que está dentro de la carpeta de Vistas>ExtNet de nuestro proyecto.

Finalmente les aparecerá la pantall de muestra de ExtNet como sigue:


De esta forma queda demostrado que ya podemos hacer uso del framework ExtNet en nuestro proyecto. Solo escriban algo en el textarea de la pantalla y den click en submit y enseguida les mostrará su mensaje en la esquina inferior derecha lo cual significa que el framework está funcionando al 100%.

Gracias por leer. En el próximo post seguiré mostrando como hago las cosas en ExtNet. Por lo pronto recomiendo visitar la galería de ejemplos en su página oficial.

Sigueme en Twitter: @Lvcios
 

lunes, 11 de agosto de 2014

Desarrollando en .NET

Hace ya poco más de tres meses que dejé de ser becario del fabuloso Centro de Tecnología e Innovación Telmex mejor conocido como CTIN Telmex y entré a trabajar a una empresa que se dedica a administrar el contenido descargable que ofrecen los portales WAP entre otros. Hablaría mas de dicha empresa pero por privacidad no lo hago, tanto de ellos como mia.

Fui contratado para desarrollar en la plataforma .NET, específicamente para programar MVC en C#. Cuando llegué realmente no sabía casi nada de C#, mucho menos de .NET. Me aplicarón un examen de conocimientos el cual aprobe y aquí me tienen. En tres meses creo que he aprendido a desarrollar en .NET mas de lo que ya sabía hacer en Django.


Por esa razón, para no enfriarme en Python y Django y aprovechar el conocimiento que estoy obtienendo de C# y Net  he decido empezar a postear todo lo que sé en ambas plataformas. Esto con el fin de que a alguién mas le sirva además de que así refuerzo mis conocimientos y bueno, quien sabe, a lo mejor y hasta termino siendo contratado para dar clases los fines de semana en alguna escuela o centro de enseñaza en computación y tecnologías para el desarrollo.

La siguiente lista corresponden a los temas que quiero desarrollar a lo largo de cada semana con tal hacerme un experto en ambas plataformas.

1. Entorno de trabajo.
2. Control de versiones
3. Hello World
4. Modelo, Controlador y Vista
5. Operaciones con modelos, controladores y vistas
6. Django vs ExtNET

Solo manejaré cosas básicas. Mas adelante espero llegar vivo a la parte de interacción con rackSpaces, API's, manipulación de archivos etc..

lunes, 26 de mayo de 2014

Lecturas del 2013

Uno de mis propósitos a cumplir durante el 2013 fue leer al menos cuatro libros. Por fortuna pude cumplirlo y no solo eso, también lo superé. En total leí 8 libros los cuales a continuación presentaré junto con un pequeño comentario acerca de su lectura. El orden en que los presento es el mismo en que los leí.

Alicia en el país de las maravillas, Lewis Carroll
La tia Tula, Miguel de Unamuno
Los 120 días de Sodoma y Gomorra, El Marqués de Sade.
Nada es eterno, Sydney Sheldon.
La conspiración del jucio final, Sydney Sheldon.
Lazos de Sangre, Sydney Sheldon.
Living Room, Sol Stein.
Zombie. Guía de supervivencia, Max Brooks.

Ahora, en este 2014 me hice el propósito de superar dicho record. Hasta el momento voy bien ya que llevo 5.

Creo que debería hacer un post mas largo ahora que ya cuento con algo de experiencia laboral, como freelancer principalmente pero no he tenido tiempo y ahora menos ya que me he dejado de ser freelancer becario por un rato para dedicarme a la vida de godinez xD.

viernes, 4 de abril de 2014

ADO.NET con Xamarin

Hace algunos posts atras, escribí sobre un ejemplo que había realizado con Xamarin para manejar bases de datos locales. El post es el siguiente: http://lvcios.blogspot.mx/2014/02/bases-de-datos-locales-en-xamarin.html.

Bueno, resulta que en ese ejemplo usé una librería que simplifica mucho el manejo, parecido a un MVC donde creas tu modelo en una clase y desde ahí lo manipulas. El problema de esa librería es el tamaño, es muy grande y no puedes realizar apps muy grandes si la usas. Por fortuna, existe la posibilidad de crear y usar bases de datos locales de forma "nativa", es decir, con SQL puro y duro. Para esto están lo recursos de ADO.NET.

A continuación proporciono el link a mi Git para que descarguen el ejemplo. Funciona de forma muy parecida al que había posteado anteriormente.

Saludos:

martes, 1 de abril de 2014

API REST con Django REST Framework (2 de 2)

Una vez ya escritos los modelos y después de haber interactuado con ellos en el administrador es momento de crear recursos para que pueden ser consumidos por una aplicación móvil o página web.

El primer paso es añadir la aplicación 'rest_framework' al settings.py. Después de esto hay que crear un nuevo archivo al cual le llamaremos (por convención) serializers.py el cual contendrá lo siguiente:

from rest_framework import serializers
from peliculas.models import *

class DirectorSerializer(serializers.ModelSerializer):
class Meta:
model = Director
fields = ('nombreDirector','pais')

class ActorSerializer(serializers.ModelSerializer):
class Meta:
model = Actor
fields = ('nombreActor','pais')

class PeliculaSerializer(serializers.ModelSerializer):
actor = serializers.HyperlinkedRelatedField(many = True, read_only = True, view_name = 'actor-detail')
director = serializers.HyperlinkedRelatedField(many = True, read_only = True, view_name = 'director-detail')
critica = serializers.HyperlinkedRelatedField(many = True, read_only = True, view_name = 'critica-detail')
class Meta:
model = Pelicula
fields = ('nombre','anio','sinopsis','director','actor','critica')

class CriticaSerializer(serializers.ModelSerializer):
criticas = serializers.RelatedField(many = True)
class Meta:
model = Critica
fields = ('pelicula','critica','pelicula')

Como pueden observar, aquí se define la forma en que se serializará nuestro modelo al ser enviado como response en forma de json. Después de esto, es momento de crear las vistas, es decir, la forma en que mostrará la información. Entonces en el archivo views.py escribimos lo siguiente:

from django.shortcuts import render
from peliculas.models import *
from serializers import *
from rest_framework import viewsets, generics, filters

class DirectorViewSet(viewsets.ModelViewSet):
queryset = Director.objects.all()
serializer_class = DirectorSerializer

class PeliculaViewSet(viewsets.ModelViewSet):
queryset = Pelicula.objects.all()
serializer_class = PeliculaSerializer
filter_backends = (filters.DjangoFilterBackend,)
filter_fields = ('director',)

class ActorViewSet(viewsets.ModelViewSet):
queryset = Actor.objects.all()
serializer_class = ActorSerializer

class CriticaPeliculaViewSet(viewsets.ModelViewSet):
queryset = Critica.objects.all()
serializer_class = CriticaSerializer

Aquí especificamos la consulta que hará la vista así como que tipo de serialización usará. De igual forma podemos definir filtros como el de PeliculaViewSet que nos servirá para filtrar las películas por director.
Ahora, para poder realmente usarlas necesitamos configurar las URL's a las que harán solicitudes las apps y páginas web. Eso lo definimos en el archivo urls.py que se encuentra en la carpeta principal de proyecto, es decir, EIMBackendTutorial:

Debe quedarnos así:

from django.conf.urls import patterns, include, url
from rest_framework import routers
from peliculas.views import *
from albums.views import *
from django.contrib import admin
admin.autodiscover()

router = routers.SimpleRouter()
router.register(r'directores', DirectorViewSet)
router.register(r'actores', ActorViewSet)
router.register(r'peliculas', PeliculaViewSet)
router.register(r'criticas', CriticaPeliculaViewSet)
router.register(r'albums',AlbumViewSet)
router.register(r'tracks',TrackViewSet)

urlpatterns = patterns('',
    url(r'^admin/', include(admin.site.urls)),
    url(r'api/v1/', include(router.urls)),
    url(r'api-auth/', include('rest_framework.urls', namespace='rest_framework'))
)

Donde el router sirve para organizar las rutas a las que se dirigirán las requests así como los recursos de los que harán uso. Finalmente estás url's las podemos agrupar bajo un mismo prefijo el cual, en este caso es '/api/v1/'.

Ahora bien. Correremos el proyecto y nos en el explorador abriremos la siguiente dirección:

Seguro nos va a marcar un error, el cual es porque no hemos configurado las opciones de REST_FRAMEWORK en el settings.py. Dichas opciones se añaden agregando lo siguiente al final del settings.py:

REST_FRAMEWORK = { 
'DEFAULT_FILTER_BACKENDS': ('rest_framework.filters.DjangoFilterBackend',),
}

Nos mostrará un formulario y un área de visualización semejante al administrador de Django. Desde ahí podemos agregar información y visualizarla en formato JSON.  Esa misma url sirve para hacer post y get usando ajax de jquery como se muestra en el ejemplo que adjunto en la carpeta AjaxExample.
Sin embargo, si ustedes lo prueban se darán cuenta que la consola del explorador marca error de CSRF. Esto ocurre porque no hemos especificado la configuración de conexiones entrantes, es decir, tal cual está nuestro proyecto solo nosotros podemos hacer post, get, put y delete. 

Para dar acceso a cualquier otra conexión o desde cualquier otra aplicación hacemos uso de la libreria django-cors-headers la cual sirve para esto. Lo único que tenemos que hacer es instalarla, lo cual ya hicimos al momento de instalar lo que venia en requirements.txt. Ahora para configurar los accesos tenemos que agregar a las apps del settings.py la app 'corsheaders' y en la sección de middlewarer_classes añadimos la siguiente línea: 'corsheaders.middleware.CorsMiddleware'. No olviden la coma al final.

Por último, al final de nuestro archivo settings.py añadimos lo siguiente:
CORS_ORIGIN_ALLOW_ALL = True 

Ya con eso es suficiente para aceptar cualquier conexión. Si desean saber más acerca de como configurar las conexiones entrantes lean la documentación de Django-cors-headers.

Finalmente, si desean desactivar el explorador por defecto del rest-framework añadimos a las opciones de rest-framework lo siguiente:

'DEFAULT_RENDERER_CLASSES': (#con esta configuracion desactivo el visor por defecto de rest_framework en todo el sistema
'rest_framework.renderers.JSONRenderer',
),

Con eso el explorador por default no estará disponible.

Hasta aquí las dos partes del tutorial

Todo el código lo pueden descargar de aquí:
https://bitbucket.org/Lvcios/eimtutorial/src


PRIMERA PARTE
NOTA: Estos tutoriales estarán en video, aumentados y corregidos en la página del EIM proxiamente.


API REST con Django REST Framework (1 de 2)

Como parte del staff del Concurso Nacional de Emprendimiento e Innovación Móvil 2014 se me solicitó realizar un minitutorial acerca de como crear una API REST usando el framework para desarrollo web "Django" el cual está escrito en Python y con el cual se pueden crear poderosas aplicaciones y sitios web altamente versátiles.

El tutorial se dividirá de la siguiente forma:
Primera parte: Creación de proyecto, apps y modelo.
Segunda parte: Django REST Framework Configuraciones de Acceso.

Anexos: Instalación de Python. Instalación de paquetes vía pip/easy_install. Archivos estáticos en Django. Uso básico de Git. Variables de entorno en Windows.

Asumiendo que ya saben usar pip install o easy_install  lo que sigue es instalar todas las librerías que se señalan en el archivo requirements.txt. El código fuente de todo el proyecto y el requirements.txt lo descargan de aqui:

https://bitbucket.org/Lvcios/eimtutorial/src

Supongamos que queremos realizar una aplicación que muestre información sobre películas, es decir, críticas, actores, director, datos importantes como cuanto recaudó, en que año salio,  cuantas nominaciones a los oscares tuvo, etc. Es claro ver que el presentar esta información en una base de datos requiere de mas de una tabla si hablamos de SQL o de modelos embebidos si estamos usando alguna base de datos NoSQL. Como sea, el primer paso es crear un proyecto en Django con el siguiente comando:

python django-admin.py startproject EIMBackendTutorial

Lo anterior creará una carpeta con el nombre especificado junto con los archivos mínimos necesarios para correr el proyecto. Para correr el proyecto entramos en la carpeta del mismo y ejecutamos el siguiente comando:

python manage.py runserver

Este comando nos indicará que nuestra aplicación está corriendo en determinada dirección la cual es por defecto http://127.0.0.1:8000/ Para romper el proceso  basta con presionar ctrl + c en la consola.

Lo que sigue es crear nuestro modelo en Django, para eso tenemos que crear una aplicación la cual llamaré "Movies" y la creo de la siguiente manera:

python manage.py startapp peliculas

Al igual que startproject, startapp crea una carpeta con los archivos mínimos necesarios para crear una aplicación. Dentro de esa carpeta tenemos el archivo models.py que es donde escribiremos nuestro modelo de datos que posteriormente será leído por el api que crearemos con RESTFramwork. Básicamente el modelo de datos seria el siguiente:

#endcoding:utf-8
from django.db import models

# Create your models here.

class Director(models.Model):
nombreDirector = models.CharField(max_length = 100)
pais = models.CharField(max_length = 100)

def __unicode__(self):
return self.nombreDirector

class Actor(models.Model):
nombreActor = models.CharField(max_length = 100)
pais = models.CharField(max_length = 100)
def __unicode__(self):
return self.nombreActor

class Pelicula(models.Model):
nombre = models.CharField(max_length = 100)
anio = models.DateField()
sinopsis = models.TextField()
director = models.ManyToManyField(Director, related_name = 'director')
actor = models.ManyToManyField(Actor, related_name = 'actor')

def __unicode__(self):
return self.nombre

class Critica(models.Model):
pelicula = models.ForeignKey(Pelicula, related_name = 'critica')
critica = models.TextField()
def __unicode__(self):
return unicode(self.pelicula) + ' ' + unicode(self.critica)


Y para poder visualizarlos en el administrador por defecto de django creamos un archivo llamado admin.py dentro de la misma carpeta con lo siguiente

# -*- coding: UTF-8 -*-
from django.contrib import admin
from peliculas.models import *

admin.site.register(Director)
admin.site.register(Actor)
admin.site.register(Pelicula)

admin.site.register(Critica)

Con esto ya es posible agregar datos a la base de datos desde el Administrador. Ahora solo queda sincronizar la bd con el siguiente comando:

python manage.py syncdb


Es súper importante mencionar que deben registrar la aplicación en el settings.py. Busquen dentro de ese archivo la sección de INSTALLED_APPS y solo agregan 'peliculas'. No olviden colocar la coma al final.

Al momento de sincronizar la base de datos nos mostrará los errores, si es que los hay. Si no hay errores entonces nos pedirá crear un súper usuario. Este paso lo podemos omitir si queremos pero en este tutorial si lo crearemos.

Una vez sincronizados los modelos con la base de datos corremos el proyecto con el comando indicado anteriormente y en el explorador tecleamos: http://127.0.0.1:8000/admin/. Encontrarán un pantalla de log-in y a continuación verán el listado de los modelos que creamos. Desde el administrador de Django ya poseé la capacidad de realizar inserciones, modificaciones, consultas y eliminaciones de registros. Recomiendo explorarlo poco a poco.

El administrador posee muchas opciones las cuales se pueden personalizar a través de código. De igual forma, los modelos se pueden manipular desde la consola y realizar operaciones y tests. Esos son temas que no veremos aquí pero están muy bien documentados en la página oficial de DjangoProject.

Hasta aquí llega la primera parte del tutorial.

El código se lo pueden descargar de aqui:
https://bitbucket.org/Lvcios/eimtutorial/src

SEGUNDA PARTE
NOTA: Estos tutoriales estarán en video, aumentados y corregidos en la página del EIM proxiamente.

sábado, 29 de marzo de 2014

Consejos de un prof de Inteligencia Artificial



Hoy no me siento muy bien que digamos, entonces un amigo me recordó lo que dijo un profesor hace como 4 años cuando tomabamos la materia de Introducción a la Inteligencia Artificial en UPIICSA.





Recuerdas al profe de inteligencia artificial?
Lara Carreño
Él consejo que dio, es de mucha utilidad... Tomar 15 minutos para reflexionar si lo que haces te llena y es lo que realmente harás el resto de tu vida.
Que nada ni nadie influya en lo que decidas







Fin del post.

miércoles, 12 de marzo de 2014

Películas Favoritas

Bueno, en realidad ultimamente si he tenido una cantidad de trabajo considerable por lo que ya no he escrito nada en el blog. He seguido trabajando con Xamarin y he aprendido también mas cosas de Django.
En fin, el día de ayer me sacaron una de las muelas del juicio, la muela derecha inferior para ser exactos y pues opté por descansar hoy. Mañana regresaré a chambear aunque con mucho cuidado.

Para no aburrirme estuve viendo películas y cibervagueando en general. De hecho este post es producto de ese ocio. A continuación mi top 20 de películas. No veo películas muy seguido y además no soy muy selectivo que digamos.

20. Terminator 2
19. One Day (Siempre el mismo día)
18. Nebraska
17. Truman's Show
16. Kill Bill (1 y 2 ya que originalmente estaban consideradas como un solo filme de 4 horas)
15. El señor de los anillos: Las dos Torres.
14. Stars Wars Episodio V: El imperio contraataca.
13. El Conjuro.
12. 500 days of summer
11. Bastardos sin gloria
10. Volver al futuro 2.
9. Tron Legacy (la del 2010)
8. Matrix
7. Ender's Game
6. The Dark Knigth (rebautizada por mi como "Batman vs The Joker")
5. Memento
4. Amores Perros
3. Una mente brillante
2. Good Will Hunting
1. Inception

En fin... como les dije no soy muy selectivo que digamos. Quizá el orden no es el mejor pero asi se me fueron viniendo a la mente, excepto Inception ya que esa es mi película favorita :3

jueves, 13 de febrero de 2014

Bases de datos locales en Xamarin

A poco mas de un mes de haber comenzado a desarrollar la app de Mi Varo en Xamarin he aprendido bastante acerca de como desarrollar apps para Android. La documentación es bastante buena para alguién que ya ha hecho cosas en "android nativo" como se suele decir. Sin embargo, para mi, que nunca había hecho nada nativo en ninguna plataforma, bueno solo esto para WP8, fue un poco complicado ya que retomé un lenguaje compilado como C# después de haber estado un par de años programado en Python y similares.

Palabras mas, palabras menos en este post les traigo un ejemplo súper sencillo de como crear y usar bases de datos locales en Xamarin. Me gustaría explicar más el ejemplo pero no tengo tanto tiempo, por eso mejor les dejo el código funcionando el cual pueden observar y descargar para su uso en :


El ejemplo consta de una tabla con dos campos, uno para el id y otro para texto. Para agregar un nuevo registro solo escribe en el campo de texto que dice "escribe" y a continuación pulsa en "crear". Automáticamente se guardará el registro, si le das tap en "mostrar" saldrá un dialog el cual te mostrará el id y el texto que escribiste, si lo quieres modificar solo escribe otro texto y le das en "modificar". Es importante que para las operaciones de modificar, eliminar y mostrar es necesario un ID, de lo contrario mostrará un mensaje de error.

Bueno, sin mas, les dejo la captura de pantalla del layout único y principal: