February 2012 - Posts
El mes pasado publiqué:
El Armado Agil de una Aplicación
describiendo algo del proyecto que está desarrollando mi equipo, usando iteraciones semanales, y un Scrum-like, con iteration backlog, reuniones diarias con compromisos y avances, revisión de iteración, etc.. Como es un proyecto privado, no puedo comentar detalles de la aplicación. Pero puedo seguir escribiendo sobre algunos avances y descubrimientos de las últimas semanas.
Primero, el núcleo de lo que estamos desarrollando, lo podemos llamar X. Es un sistema a consumir, no directamente, sino por otros sistemas. En vez de desarrollarlo completamente, lo que estamos haciendo es encarar los casos de uso. Por ejemplo, en la penúltima semana construimos una aplicación A, símil de otra existente en la empresa contratante. Es una aplicación con interfaz web para usuarios, que consume los servicios básicos de X:
A –> X
Luego, en esta última semana, pusimos a prueba algunos conceptos de seguridad de X, que fueron aplicados exitosamente en la aplicación A. Además, hicimos una variante nueva de A, digamos A1, que tiene algunas características adicionales que no existen en la aplicación real en uso. Eso sirvió para que el “product owner” vea que X es lo suficientemente poderoso y flexible para lo que queremos hacer, AUN SIN ESTAR totalmente definido e implementado. Todo esto gracias a algo que comenté en el post anterior: NOS CONCENTRAMOS EN LOS CASOS DE USO, en vez de ir pensando e implementando en detalle TODO X. De hecho, el dominio de X, y los de A, siguen estando en memoria, y no hemos tenido que definir tablas, bases de datos, blob storage, todos artefactos que todavía no necesitamos (igual tenemos el código preparado para tener ese tipo de persistencia, y ya lo hemos probado en los casos simples).
En la reunión de revisión de iteración de ayer, surgieron dos temas, que me parecen que son hitos en este proyecto.
Uno, ha ido emergiendo qué es la “esencia” de X, los servicios fundamentales de este “engine” a ser consumidor por aplicaciones. Por ejemplo, visitamos aplicaciones reales de otras empresas, y VIMOS que podríamos reimplementar lo que brindan usando el “engine” X por debajo. Para eso poner a prueba eso, ya tenemos los casos A, A1, de aplicaciones reales implementadas parcialmente.
Otro, es también interesante, aunque no tan relacionado tanto con el “engine” X. El “product owner” planteó que lo que más le sumaría valor, para las próximas iteraciones, sería implementar B, una aplicación que refleje un proceso ya existente en la empresa, pero que se maneja semi-informalmente en planillas Excel (jeje… todos tenemos esto en nuestro karma ;-). Esta vez, la idea es llegar más allá de una simple implementación A. Ahora queremos armar un B que se ponga en uso real. El PO eligió este caso, guiado por el valor que gana: implementar totalmente A sobre X, no agrega tanto valor, porque YA HAY una aplicación preexistente, funcionando, del tipo A. En cambio, la aplicación B va a implementar algo que no existe todavía como aplicación en la empresa.
Pero ahí apareció algo nuevo, en la discusión: la necesidad de tener una aplicación C, que facilite el trabajo de los usuarios. Todo nació de una frase tipo “Tim necesita … “. Y ese fue el “key point”: al analizar QUE necesitaba, y POR QUE, pudimos llegar a comprender cuál es el problema a resolver, más allá del tema puntual de planillas Excel y proceso. Y ahí apareció cómo los usuarios podrían usar lo que estamos haciendo, de una forma MAS ORIENTADA a lo que necesitan. Lo que quedó claro ayer, es que podemos usar una metáfora (disculpen de nuevo, no hay mucho detalle a mostrar) que nos va a guiar en las siguientes iteraciones, al implementar la funcionalidad de B y de C. Iremos probando su efectividad, viendo qué funciona y qué no, en el uso de los usuarios.
Y quiero destacar: esto no surgió solamente de un equipo “iluminado” que dice “hay que ir por acá”, o que dijo “hay que usar la tecnología tal y cual, porque tiene las características … “. Tampoco fue “bajada de línea” del cliente. Surgió de la interacción con sinergia del PO, y del centrarse en los casos de uso y problemas a resolver.
Nos leemos!
Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez
Ayer escribía sobre el Ruby Meetup de Buenos Aires, y describí que había gente de la comunidad a la que no le gustaba Rails, el framework y herramientas de desarrollo de sitios web más popular de Ruby. En la lista RubySur, ayer se disparó el hilo
Rails, sucks?
donde apareció, ante la pregunta: que es más popular? rails, cuba o sinatra ? la respuesta: “Rails. Las masas siguen a las masas. Las masas no son muy inteligentes tampoco.” Escribí en ese lista, en dos emails, que discrepo con esa respuesta. Pueden leer todo el contexto y posiciones alternativas en ese hilo. Acá, en este post, quisiera pasar en limpio algo que muchas veces comento pero veo que no escribí en detalle y como tema principal.
Primero, el tema me interesa, porque he visto aparecer, desde hace dos décadas, argumentos como ése: la tecnología X se adopta sin pensar, sin conocimiento, y para usar la expresión de arriba, “siendo masa”. Me refiero acá a tecnología de programación (desde lenguajes, IDEs, sistemas operativos de soporte, frameworks, herramientas, editores, etc…) y podría extenderlo a TI en general. Pero acoto por ahora, a temas de desarrollo de software. He visto aparecer argumentos y explicaciones similares a la de “la masa” en otras listas, por ejemplo, en listas de Smalltalk o de COBOL o de Linux. Sigo sin ver que sea ése el caso. Salgo de mi cubil, me fijo, y sigo sin ver que sea así. Insisto: me refiero a decisiones de desarrolladores y aledaños.
He estado repasando más de treinta años en mi vida de ser desarrollador, y no he podido encontrar el caso de “masa (de desarrolladores) elige tecnología X”. Porque no he visto, encontrado, el caso “masa”. Siempre lo que veo, son individuos que eligen. Veo a Juan estudiante, viendo qué lenguaje de programación más le gusta o interesa. Veo a José viendo cuáles son las tecnologías que tienen más salida laboral, porque su profesión es el desarrollo, y eligiendo entonces. Veo a Ana, gerente de una compañía, decidiendo si importa o no la tecnología a usar en el próximo desarrollo de la intranet de la empresa, sopesando disponibilidad de gente con conocimiento en las tecnologías, costo de implementación (en tiempo y dinero), costo de mantenimiento, y posibilidades de expansión en nuevas versiones. Veo a Diego y María eligiendo qué usar para su próximo emprendimiento de “social media” + “semantic web”.
Aun en los tiempos pre-web (y con escasa Internet en Argentina), la gente tenía varias opciones para elegir, y decidía de forma individual, no como “masa”. Por supuesto que las empresas que producen tecnología (y más en los ochenta, donde esa producción estaba más concentrada) ejecutaba todas las acciones de mercadeo y promoción, pero nunca ví que la elección de herramientas y tecnologías se volviera algo como el ámbito de la música, donde podemos discutir si “la masa sigue a la masa”. Realmente no lo ví y no lo veo.
Es claro que las decisiones se toman en un contexto (“tengo que trabajar y lo que piden es Java”), y se toman con conocimiento parcial (“adopto Rails, veo que tiene una comunidad activa pero no sabía que había otros frameworks”). Pero ese conocimiento parcial se aplica individualmente, no por actuar como “masa”. Si hay conocimiento parcial, y hay poco conocimiento de la tecnología Y, y pensamos que esa tecnología es interesante, debemos difundirla. Casi de cada cosa que encuentro interesante, termino escribiendo un post, o por lo menos, dando una lista de enlaces en mi delicious o enviando enlace en mi twitter. Pero veo, por ejemplo en el ámbito Smalltalk, que los que no lo adoptan y “dicen programar en objetos” en otras tecnologías, son parte de “la gilada” (no sé si se entiende, “gil” en Argentina sería algo así como “tonto” en español “neutro”). Esa actitud no corresponde con la realidad (no veo que alguien que no use Smalltalk y use .NET o Java, sea “tontos” o no hayan aplicado su inteligencia para haberlos elegido). Y adoptarla, disminuye la posibilidad de entender cómo cambiar la realidad: cualquier fracaso en la adopción de Smalltalk se refugiará en ese argumento, “ves, la gilada no lo entiende”.
El tema que discuto, no es tanto el uso de conocimiento parcial, intuición y demás, que se entienda o no algo, sino el modelo propuesto de “la masa sigue a la masa”. No veo “masa” en la historia del desarrollo de software.
Entonces, ¿cuál es el modelo que podemos proponer, para explicar la adopción de tecnología X? Bueno, no hay un modelo simple (otro argumento en contra de “masa sigue a la masa”). Cada individuo elige en su contexto, intereses y capacidades. Pero puedo proponer el modelo de varios individuos, digamos Pedro tiene que elegir tecnología:
- No tiene todo el tiempo para analizar y elegir la mejor opción
- Tambien puede ser lo bastante inteligente para decir: "Aunque analice, mi conclusion no es segura"
- Decide que es mejor seguir un camino donde hay una comunidad activa
- Con eso cumple con el time to market
- Elige X, que tiene una comunidad activa, con paquetes (gemas, módulos, etc…) y mucha gente que la conoce
- Claro, X técnicamente no es perfecto, hay otras opciones, pero no las elige
- Cuando crece, tiene muchos desarrolladores que conocen X
- Y con eso se forma una empresa y se compra una casa en un barrio privado :-)
Luego, otros tendrán otros modelos. Por ejemplo, alguien en ese hilo de RubySur, explicó que su consultora programaba muchas veces en Rails para que el cliente final tuviera un producto que muchos desarrolladores de la comunidad Rails pudieran mantener y extender. El cliente final así elige en contexto: para él, lo importante no es la excelencia técnica del producto final (“mirá, tal otro framework es más desacoplado, aplica MVP de forma más pura, etc… “), sino que cumpla con su función y pueda ser soportado en el futuro sin tener que contratar gente de la NASA. ¿Es parte de “la gilada”? No, es parte de su trabajo ese tipo de elecciones.
Un ejemplo que ví hace unos años: un sistema en Smalltalk, con Gemstone, hermosamente armado, muy dúctil. Pero cuando el tiempo pasó, y se le pidió más funcionalidad, prácticamente no había gente suficiente a un costo adecuado para extenderlo a tiempo. Y tampoco se podía consumir fácilmente sus datos desde otras tecnologías. Al lado de ese sistema, en tecnologías más difundidas, había otros que fueron creciendo y pasaron a ser el “core” de soporte de decisiones de la empresa.
Otro modelo es el de Francisco, gerente de TI:
- Tiene que elegir tecnología para resolver problema A
- Tiene opciones X, Y (y tal vez desconozca otras, como Z, W que son técnicamente mejores)
- Y le parece buena, y hasta mejor que X
- Pero tiene como proveedores a 20 consultoras que conocen X, en la última reunión de CIOs se comentó que el proveedor principal de Y no cumple con los tiempos, hay un grupo de usuarios activo de X
- Elige X
¿Es parte de “la gilada”? El sentarse con otros CIOs y compartir experiencias, ¿lo hace parte de la masa? No lo veo.
Y así puedo seguir enumerando modelos, cada uno servirá de explicación aproximada a la forma de adopción de X por el conjunto de individuos {A}. Lo que no veo es un conjunto “gilada” o conjunto “masa”.
Veamos, para ir cerrando, un modelo propuesto de adopción de tecnología (ahora paso a tecnología en sentido amplio, más allá de programación). Lo encontré hace más de 15 años en el libro Crossing the Chasm de Geoffrey Moore, modelo que se puede discutir, pero es interesante para sumarlo a esta exposición. Ahí se propone que hay:
the technology adoption lifecycle where five main segments are recognized; innovators, early adopters, early majority, late majority and laggards. According to Moore, the marketer should focus on one group of customers at a time, using each group as a base for marketing to the next group. The most difficult step is making the transition between visionaries (early adopters) and pragmatists (early majority). This is the chasm that he refers to. If a successful firm can create a bandwagon effect in which enough momentum builds, then the product becomes a de facto standard.
Vean que en los tiempos de Moore, ni se pensaba que podría haber tecnología creada fuera de una empresa (como Hibernate o Linux por ejemplo). Lo que ha traído la Web (antes también Internet, pero hay que reconocer que la Web fue disparador) es la formación de comunidades que soportan tecnologías. Hay innovators, como Rick Hickey con Clojure, o Ryan Dahl con Node.js; hay early adopters, que los acompañan en los primeros tiempos, y luego, hay un “cruzar el abismo”, donde se ve si la tecnología llega a formar parte del “mainstream” de opciones. Vean que Moore menciona “pragmatists (early majority)”. Por más “cool” que se vean Clojure, Node.js, Rails, Agile, Hadoop o tecnología X, sólo “explotan” cuando terminan dando resultados a gente pragmática, que con ellos puede conseguir objetivos: desarrollar un sistema real en uso, armar un emprendimiento, construir un nuevo producto.
Vean un tema nuevo que aparece en estos años: la formación de comunidad. Una tecnología X puede no ser la mejor solución, pero puede tener una comunidad activa, que produce ejemplos, documentación, herramientas. Notablemente, en tecnologías X que pueden extenderse por partes de terceros. Eso le da una vuelta de tuerca al concepto de comunidad: son las gems de Ruby, los módulos de Node.js, y los paquetes de NuGet. Mucha gente adopta tecnología X porque soluciona sus problemas. Y en esa decisión pesa mucho el tener una comunidad a la que recurrir, en casos de trabarse en algo. Y vean cómo ha influido Internet/Web en la formación de comunidades, tal vez en detrimento de grupos de usuarios locales y localizados.
Bueno, espero que lo que quise explicar haya quedado clarito como huevo de tero. Por supuesto, acepto otras posiciones, pero van a tener que convencerme. Por ahora, dejo este post como evidencia de mi postura.
Nos leemos!
Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez
Ayer, jueves 9 de Febrero, asistí a mi primer meetup Ruby de Buenos Aires. Cumpliendo con el “mindset” toda actividad tiene que tener un “outcome” consumible, hoy escribo post sobre mi experiencia en la reunión. La comunidad Ruby de Argentina (@rubyargentina) ya hizo varios meetups, me cuentan que desde fines de 2010, y que habrán sido como una decena. Tratan de hacerlo mensualmente, excepto en algunos meses de poca actividad (o de mucha, como fue el caso del año pasado con la Ruby Conf Argentina, primera conferencia de ese tipo en mi país).
Esta vez fue anfitrión de la meetup Vurbia @Vurbia
http://www.vurbia.com/lang-en/
Ellos proveen soluciones de Infrastructure as a Service, vean
http://www.vurbia.com/services/xephstratus-managed/solutions
Por lo que me comentaron, tienen su plataforma propia de virtualización, además de todo un stack de servicios. Me encontré, creo que por primera vez, con @pemendez, no me habìa dado cuenta que era vurbiano. Hoy comencé a seguir también a otra vurbian @cbecketts.
El lugar de reunión fueron las oficinas de Vurbia en Guatemala 5000 (esquina Uriarte), en el barrio de Palermo, Buenos Aires. Una esquina excelente, con árboles. Nos ubicamos en la terraza, donde ya había cerveza tirada y cantidades de papas fritas. Yo llegué a las 19hs, y ya había cerca de 10 personas. Se fue llenando, habrá llegado a hacer 40 o más. Buen atardecer de verano, brisa fresca, árboles palermitanos desde la terraza, y cerveza, que mas?
Al contrario de lo que había comentado @etagwerker en la lista RubySur no comenzó puntualmente a las 19hs. Y estuvo bien, con cerveza y papa fritas, hubo intercambio social, conversaciones en grupo, sobre desarrollo, o sobre cualquier otra cosa, desde “no me gusta Tandil” hasta “un compañero de trabajo subió ayer las escaleras del Empire State" :-). Fue tanta gente que no había salón, oficina para dar una charla, ni tampoco se pudo contar con un proyector. Pero no importó: lo interesante es que, según los miembros de la comunidad, esta vez fue la reunión con más gente que tuvieron.
Yo me había comprometido a dar una charla técnica sobre AjLisp en Ruby, mi experimento de Ruby, TDD para ir aprendiendo algunas cosas. Como fui el primero de los oradores en llegar, me tocaba primero a mí. Pero como había basado mucho de la charla en escribir en el REPL (Read Eval Print Loop) del proyecto, y en ver código en el editor, decidí no mencionar mucho del tema. Habrá sido como a las 20hs que se decidió que había comenzar con las charlas, y se trajo una gran pizarra. Me presentaron, y comencé mi charla. Pregunté si había otro orador presente, para saber si tenía tiempo para un experimento, y no contestó nadie. Entonces decidí que lo mejor era aprovechar la oportunidad, y en vez de hablar de AjLisp con solo la pizarra, sería mejor para todos emplear el tiempo en otra cosa. Me decidí por preguntar a cada uno de los presentes: nombre, experiencia, y por qué su interés en Ruby. Creo que el experimento salióbien, y permitió que todos nos conociéramos un poco más.
Resultado: de todo un poco. Había gente que programaba en Ruby desde hace 8 o más años, muchos que comenzaron hace 2 o 3 años, otros que comenzaban recién. Había empresas unipersonales, y también empresas ya con varios desarrolladores. Gente que trabajaba para Argentina, y otros que trabajaban para afuero (creo que mitad y mitad). Dos personas amantes de Ruby. Alguno que pasó por ASP (no sé si por ASP o ASP.NET), varios desertores de Java, algunos que trabajon en .NET. Descubrí las posiciones de algunos miembros de la comunidad respecto a Rails: hay algunos que prefieren otras formas y frameworks para programar web en Ruby. Los más activos miembros de la comunidad son escritores de gemas. Había dos personas de Mercado Libre, que comentaron su experiencia “evangelizando" Ruby internamente, habiendo comenzado con 5 “conversos” y actualmente llegando a algunas decenas en la gente de QA. Había dos extranjeros (creo que americanos, uno bilingüe, otro de Nuevo Méjico sólo hablando inglés, ambos muy entusiasmados con la comunidad que encontraron). Había gente que se llegó desde las ciudades de Santa Fé y Rosario. Estaba el CIO de la startup restorando, pueden ver http://buenos-aires.restorando.com.ar/ pero con proyección a Latinoamérica (ahí está el bueno de @bilinkis). Es una implementación, que por lo que comentaron, tiene como referente al americano Open table http://www.opentable.com/. Cuando ya estábamos en este ejercicio, llego @etagwerker que está trabajando en Ruby en su lean startup http://www.ombushop.com/. Es interesante ver que había muchos que estaban trabajando en su propia empresa: no sabría poner un porcentaje, pero me pareció mayor que el que encuentro en otras comunidades, como Smalltalk o ALT.NET Hispano.
Al fin, me llegó el turno de presentarme, comenté el origen de mi nickname, y de la cantidad de tecnologías que tuve que ver. Describí que mi interés en Ruby es una extensión de mi interés en los lenguajes de programación. Me hicieron preguntas sobre AjLisp, que derivaron también en explicar cómo Ruby me interesa por ser extensión (o al menos, basado en) lenguajes como Smalltalk y Lisp. Pero mi respuesta, algo larga, daría para otro post, prometo escribirlo :-)
Como saben los que me siguen por twitter, cuando uno está más cerca del arpa que de la guitarra, trata de organizar su tiempo. Así que me había reservado hasta las 21hs estar en la meetup. A las 21:05 comenzó una divertida charla, a cargo de Leandro Marcucci, ver https://github.com/leanucci, sobre su gema https://github.com/vurbia/Bravo así que me quedé hasta las 21:30. Vean el repositorio de la gema, no quiero escribir acá, me da cosita, porque trata de temas impositivos de Argentina :-) Pero había por lo menos dos grupos más que también habían desarrollado ese tipo de acceso a servicios del gobierno en Ruby, y por lo menos uno más que lo había hecho en .NET. Leandro fue el encargado de atendernos, y estuvo toda la reunión subiendo y bajando las escaleras para poder abrir la puerta a la gente que llegaba a la meetup.
La gente siguió con la reunión (creo que había una charla de Amazon Web Services desde Ruby), pero ya no estuve, así que no tengo más info sobre la reunión. Si me acuerdo de algo más (ah, sí, rifaron una remera de GitHub, creo), escribo por acá.
Agradezco a la gente de Vurbia y de la comunidad de Ruby por haberla organizado, muy buena onda, cerveza con papa fritas, y good show!
Nos leemos!
Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez
Ya estuve escribiendo una serie de posts sobre mi experiencia en el pasado Ruby Fun Day en Buenos Aires:
Mi Día en el Ruby Fun Day con @bendycode
Ahora quiero comenzar a pasar en limpio mis pasos de aprendizaje estudiando el capítuylo 2 del libro de Michael Hartl : Ruby on Rails Tutorial: Learn from Example. Yo estoy siguiéndolo con la versión 3 de Ruby on Rails.
Ya había instalado Ruby en mi máquina Windows, usando http://rubyinstaller.org/ (otras opciones en http://www.ruby-lang.org/en/downloads/). En Windows, debemos instalar también DevKit (un “minimalist GNU for windows” (mingw)). Vean la página de Ruby Installer para el enlace de bajada. Las instrucciones para instalarlo están en http://github.com/oneclick/rubyinstaller/wiki/Development-Kit. (otros detalles).
Luego de todo eso, ejecuté el comando para instalar rails, en cualquier command prompt:
gem install rails
lo que instala Ruby on Rails, el framework de desarrollo de sitios web escrito en Ruby. Vean que es una gema (gem) que se instala como cualquier otra estando en línea. Ahora vamos a un directorio de trabajo (en mi caso c:\Git), donde ejecutamos
rails
Salida:
Luego ejecuté
rails new RailsDemoApp
con salida:
Eso crea un nuevo directorio, me cambio a ese:
cd RailsDemoApp
Este es el árbol de directorios que tengo:
Ruby maneja gemas (paquetes a instalar). Como vimos, Rails mismo es una gema. Y una aplicación Rails, como la recién creada, tiene un archivo GemFile donde se especifican las gemas que esta nueva aplicación necesita. Es usual entonces apelar a un programa que revisa ese archivo e instala cualquier gema que se necesite y no esté instalada. Ejecuto:
bundle install
Bundle es el nuevo instalador de paquetes que usa Ruby on Rails 3. Lee el archivo GemFile e instala (en el directorio de Ruby, en nuestra máquina, no en el directorio de la aplicació) las gemas que necesite. Ahora podemos ejecutar:
bundle show
Configuré el directorio actual (Git\RailsDemoApp) para que sea un repositorio Git:
git init
git add .
git commit –m “Initial Commit”
Agregué un nuevo repositorio en mi cuenta de GitHub usando https://github.com/repositories/new:
El nuevo repo: https://github.com/ajlopez/RailsDemoApp
Lo agregué como repositorio remoto a mi repo local, y envié lo que tengo a GitHub:
git remote add origin git@github.com:ajlopez/RailsDemoApp.git
git push origin master
Ya desde la instalación de bundle, podemos lanzar el servidor con
rails server
o en su forma corta
rails s
Veo el resultado en http://localhost:3000
Próximos pasos, para siguientes posts: agregar un modelo simple (usuarios, y microposts, con relación uno a varios), base de datos, vistas, controladores, “scaffolding”, y despliegue en Heroku. El Scaffolding (generació de código para CRUD) será la aproximación a usar en los próximos posts, como en el libro de Hartl, pero despues me gustaría escribir sobre cómo construir un sitio Rails paso a paso, como hace el mismo Hartl a partir del capítulo 3 de su libro.
Nos leemos!
Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez
El bueno de Oscar Zárate, desarrollador argentino radicado desde hace unos años en la lejana Australia, nos dará una charla virtual (VAN) en Alt.NET Hispano, el próximo sábado. El tema es sobre desarrollo ágil sobre Sharepoint. Oscar nos contará su experiencia en el desarrollo en equipo de un proyecto. Escribió Oscar:
Para todos los interesados en la VAN de este sábado voy a mostrar "que hicimos" y "como hicimos" este sitio
http://financial.markets.nab.com.au
Está basado en SharePoint 2010.
Las herramientas/prácticas que usaron:
- Continuous integration
- Continuous Deployment
- One click deployment
- MVP pattern para los WebParts
- Moles
Estos son los datos de la reunión
VAN sobre Sharepoint practicas y herramientas
Fechasáb, 11 de febrero, 19:00 – 21:00 (hora universal. Acá en Buenos Aires es GMT-3, así que será de 16 a 18hs)
Lugar http://snipr.com/virtualaltnet (es reunión virtual)
DescripciónLa comunidad ALT.NET Hispano (http://altnethispano.org) realizará una VAN sobre Sharepoint practicas y herramientas, con Oscar Zarate. Fecha: Sábado 11 de Febrero del 2012 a las 19:00 hrs. Hora Internacional (GMT/UTC), con una duración aproximada de 2 horas. Pueden plantear sus comentarios e inquietudes sobre el tema de la reunión en: https://groups.google.com/d/topic/altnet-hispano/GsMgkNjpUg0/discussion Para mayor información sobre cómo atender la reunión consulten: http://tinyurl.com/van-hispano
Nos leemos!
Angel "Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez
Anterior Post
Una de las grandes “features” de Rails es poder generar código, definiendo un modelo simple. En el curso decidimos implementar una lista de charlas, con oradores. Para Orador, definimos modelo Speaker y se generó código con:
La clave es la opción generate del comando rails. Con esa opción se pueden generar distintos archivos de texto, con scaffold genera los controladores, vistas, y modelos, con acceso a datos, de un modelo simple. El modelo se describe con Speaker name:string (se pueden poner más campos de distintos tipos).
Generó varios archivos, como app/models/speaker.rb:
class Speaker < ActiveRecord::Base
end
O el controlador app/controllers/speakers_controller.rb:
class SpeakersController < ApplicationController
# GET /speakers
# GET /speakers.json
def index
@speakers = Speaker.all
respond_to do |format|
format.html # index.html.erb
format.json { render json: @speakers }
end
end
# GET /speakers/1
# GET /speakers/1.json
def show
@speaker = Speaker.find(params[:id])
respond_to do |format|
format.html # show.html.erb
format.json { render json: @speaker }
end
end
# GET /speakers/new
# GET /speakers/new.json
def new
@speaker = Speaker.new
respond_to do |format|
format.html # new.html.erb
format.json { render json: @speaker }
end
end
# GET /speakers/1/edit
def edit
@speaker = Speaker.find(params[:id])
end
# POST /speakers
# POST /speakers.json
def create
@speaker = Speaker.new(params[:speaker])
respond_to do |format|
if @speaker.save
format.html { redirect_to @speaker, notice: 'Speaker was successfully created.' }
format.json { render json: @speaker, status: :created, location: @speaker }
else
format.html { render action: "new" }
format.json { render json: @speaker.errors, status: :unprocessable_entity }
end
end
end
# PUT /speakers/1
# PUT /speakers/1.json
def update
@speaker = Speaker.find(params[:id])
respond_to do |format|
if @speaker.update_attributes(params[:speaker])
format.html { redirect_to @speaker, notice: 'Speaker was successfully updated.' }
format.json { head :ok }
else
format.html { render action: "edit" }
format.json { render json: @speaker.errors, status: :unprocessable_entity }
end
end
end
# DELETE /speakers/1
# DELETE /speakers/1.json
def destroy
@speaker = Speaker.find(params[:id])
@speaker.destroy
respond_to do |format|
format.html { redirect_to speakers_url }
format.json { head :ok }
end
end
end
Y distintas vistas en app/views/speakers como index.html.erb:
<h1>Listing speakers</h1>
<table>
<tr>
<th>Name</th>
<th></th>
<th></th>
<th></th>
</tr>
<% @speakers.each do |speaker| %>
<tr>
<td><%= speaker.name %></td>
<td><%= link_to 'Show', speaker %></td>
<td><%= link_to 'Edit', edit_speaker_path(speaker) %></td>
<td><%= link_to 'Destroy', speaker, confirm: 'Are you sure?', method: :delete %></td>
</tr>
<% end %>
</table>
<br />
<%= link_to 'New Speaker', new_speaker_path %>
Luego, levantamos el servidor de nuevo con:
rails server
Levanta el servidor como antes, pero si navegamos a http://localhost:3000/speakers
Resulta que se generó código para soportar una lista de oradores, y una tabla de oradores en la base de datos, pero esta última todavía está vacía, sin la tabla correspondiente. El generador de código de Rails se encargó de dejar también los comandos de actualización de la base. Ejecutamos:
Vean que crea la tabla de Speakers (ver el directorio db/migrate donde quedó un archivo que define el paso 20111218214020_create_speakers.rb:
class CreateSpeakers < ActiveRecord::Migration
def change
create_table :speakers do |t|
t.string :name
t.timestamps
end
end
end
Noten que el nombre del archivo tiene la fecha/hora de creación, para luego reproducir en orden los comandos contra la base de datos para que ésta quede actualizada. Ahora, navegamos de nuevo a http://localhost:3000/speakers:
Puedo dar de alta un orador:
Y el resultado es:
Bien! Ya tenemos nuestro primer modelo simple, y las páginas (noten las URLs que se formaron) para manejarlo.
Próximos temas: extendiendo el modelo, relaciones uno a varios, desplegando en Heroku.
Nos leemos!
Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez
Primero, una revisión de mis resoluciones de Enero:
- Implementar Id en los nodos de AjCoRe (simple Content Repository) Parcial
- Implementar Cliente/Servidor en AjKeyvs (Key Value Store) Completo
- Comenzar una nueva versión de mi framework simple PHP, rejuveneciendo uno viejo de principios de siglo, a publicar en mi cuenta de GitHub Completo ver AjFwkPhp
- Publicar un ejemplo de servidor simple en mis ejemplos de Node.js Completo
- Publicar un juego simple en HTML5/Canvas game usando Node.js como servidor del juego (en Node.js samples) Completo (en vez de un juego, publiqué un simple dibujador de canvas distribuido, igual extendí Social Gaming Toolkit para usar Node.js)
- Continar trabajando en mi intérprete AjLang, con sintaxis tipo Ruby, que maneja tipos y objetos .NET Completo
- Continuar trabajando en AjLisp en Java Pendiente
- Jugar con Clojure REPL Pendiente
- Comenzar a escribir AjRools.Expert, un “rule engine” en C#, a la JBoss Drools Expert, pero con el algoritmo desarrollado desde cero, usando TDD, a publicar en mi GitHub) Completo ver AjRools
Mis resoluciones para Febrero:
- Implementar primeros comandos ADO.NET en AjBase (in memory database)
- Implementar Id y propiedades read/write en AjCoRe (simple Content Repository)
- Comenzar a escribir AjComprobantes, una aplicación simple en PHP (en Español) para poner a prueba el AjFwkPhp
- Preparar una presentación acerca de lenguajes de programación (a dar en el local Microsoft User Group de Buenos Aires, en Marzo)
- Dar una presentación sobre AjLisp en Ruby en el Ruby Buenos Aires Meetup
- Preparar una presentación sobre Clojure (espero darla en el meetup de Java User Group en Marzo)
- Escribir un REPL para mi AjLisp in Ruby
- Más código en AjContab (tengo que decidir si en la versión PHP o en la .NET)
- Templates en AjGenesis en Ruby
- Agregar soporte de objetos en las reglas de AjRools Expert
- Agregar métodos con parámetros AjLang
- Escribir post sobre mi trabajo en AjRools
- Nuevo post sobre mi trabajo en AjLisp en Ruby
- Nuevo post sobre mi trabajo en AjBase
- Jugar con Clojure REPL
- Post sobre Entendiendo Node.js (primero de una serie)
- Post sobre Entendiendo Git (primero de una serie)
Bien, tengo trabajo! ;-) Como en mi anterior lista, mucho de estos items tienen un entregable público. Es una larga lista: estoy empujándome a hacer cosas!
También tengo una lista de resoluciones no técnicas para Febrero.
Agregados:
- Probar Radarc, generador de código para Visual Studio
- Primera implementación de Reflection en AjLisp en Java.
Nos leemos!
Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez