June 2007 - Posts
El bueno de Augusto Alvarez nos alcanza un video que, cada vez que lo muestro en una charla, causa sensación. Desde los archivos de YouTube, viene el primer usuario, vean cuáles eran sus problemas, dudas y soluciones:
Más Videos para Programadores
Nos leemos!
Angel "Java" Lopez
http://www.ajlopez.com/
En estos días, estuve escribiendo unos ejemplos de AjGenesis
http://www.ajlopez.com/ajgenesis
mi proyecto de código abierto de generación de código, para producir, desde un modelo, aplicaciones tanto en ASP.NET 1.x/2.x, como en JSP, tanto usando SQL Server en el primer caso, como con MySql en Java, y tanto con ADO.NET, como con NHibernate, Hibernate, ya sea con arquitectura de capas, como en capas a la Domain-Driven Design de Evans.
Sigo escribiendo esos ejemplos, pero ya hay algo publicado en
AjGenesisExamples3.zip
Usaremos la versión del proyecto que está actualmente en desarrollo:
AjGenesis-0.4.3.zip
Quisiera en este artículo, comentar cómo funciona y se construye, uno de esos ejemplos. Permítanme primero repasar algo sobre el proyecto. Primero, "the big picture":
Está escrito en Visual Basic .NET 1.x, y es código abierto, pues viene con una licencia tipo BSD, que permite utilizarlo en cualquier proyecto que quieran. Se puede usar como librería, invocado desde nuestro proyecto, se puede invocar desde la línea de comando, o puede ser utilizado desde el poderoso NAnt (esto último me permitió organizar mejor las tareas que realiza el generador de código).
En la página del proyecto (y en el proyecto mismo) hay varios ejemplos, que generan código desde un modelo, usando plantillas. Los ejemplos generan código PHP, Java, JSP, VB.NET, C#, ASP.NET, y hasta scripts de base de datos y procedimientos almacenados. Quisiera destacar dos puntos:
- El modelo del que parte es totalmente definible por el usuario
- Las tareas y plantillas a aplicar son totalmente programables y controlables
Esto lo diferencia de otros generadores. Podemos construirnos nuestro propio modelo, y sus propias plantillas, para generar los artefactos de texto que prefiera. Otros sistemas parten de la base de datos, y sólo generan un grupo de artefactos de textos predefinidos (por ejemplo, POJOs, plain old java objects, o DAOs, Data Access Objects). Pero con AjGenesis puede generar el artefacto de texto que se nos ocurra.
Para comprender mejor que el modelo se puede construir y consumir como uno lo disponga, ver un artículo anterior:
Generando Código- Hello World con AjGenesis
Ahí se describen los pasos iniciales, y un modelo que es totalmente libre.
Creando una aplicación
Encaremos hoy algo más completo. Necesitamos armar una solución sencilla, con dos tablas, sobre una base de datos SQL Server, con código VB.NET 2.0, con interface web, capa de servicios, capa de datos, entidades y componentes de negocio a la Microsoft. Queremos generar la solución, los proyectos, los scripts de creación de la base, y procedimientos almacenados. Este ejemplo está incluido en los ejemplos AjGenesisExamples3.zip. Primer paso: escribir el modelo.
El proyecto
En un directorio de proyectos de los ejemplos que acompañan este artículo, hay un directorio Projects/AjFirstExample.
En ese directorio está el archivo Project.xml que contiene el modelo.
<Project>
<Name>AjFirstExample</Name>
<Description>First Example using AjGenesis</Description>
<Prefix>AjFE</Prefix>
<Domain>com.ajlopez</Domain>
<CompanyName>ajlopez</CompanyName>
<Model>
<Entities>
<Entity Source="Entities/Customer.xml"/>
<Entity Source="Entities/Supplier.xml"/>
</Entities>
</Model>
</Project>
Recordemos: el modelo es libre. Acá definimos, para los templates que vamos a usar, las entidades de nuestro modelo: customers y suppliers.
Las entidades
Para que un archivo XML no resulte terriblemente largo, AjGenesis permite que cualquier nodo del modelo se especifique en un archivo aparte. Es un criterio que he usado para definir cómo se escribe el modelo: el XML resultante no debe herir a la vista, debe ser entendible y abarcable en una lectura.
En el Project.xml, eso aparece en el caso de las entidades, con el atributo Source. Examinemos una entidad, escrita en Entities/Customer.xml:
<Entity>
<Name>Customer</Name>
<Description>Customer Entity</Description>
<SetName>Customers</SetName>
<Descriptor>Customer</Descriptor>
<SetDescriptor>Customers</SetDescriptor>
<SqlTable>customers</SqlTable>
<Properties>
<Property>
<Name>Id</Name>
<Type>Id</Type>
</Property>
<Property>
<Name>Name</Name>
<Type>Text</Type>
<SqlType>varchar(200)</SqlType>
</Property>
<Property>
<Name>Address</Name>
<Type>Text</Type>
<SqlType>text</SqlType>
</Property>
<Property>
<Name>Notes</Name>
<Type>Text</Type>
<SqlType>text</SqlType>
</Property>
</Properties>
</Entity>
Hay atributos de la entidad, como su nombre y descripción, en singular y plural, que sirve para nombrarlas en las páginas resultantes, o dentro del código. Las propiedades son los campos a mantener en cada entidad. Vemos que en este ejemplo, no hay más que datos dentro de una entidad.
Aparte de las entidades, en otro directorio, Technologies, se especifica el modelo dependiente de la tecnología, como VbNet2:
<Technology>
<Programming>
<Dialect>VbNet2</Dialect>
</Programming>
<Database>
<Dialect>MsSql</Dialect>
<Name>AjFirstExample</Name>
<Username>sa</Username>
<Prefix>ajfe_</Prefix>
<Host>(local)</Host>
</Database>
</Technology>
Las plantillas
En el directorio Templates/VbNet2 encontramos
Son las plantillas para generación de código VB.Net 2.0. También encontraremos plantillas para C# 1.x y 2, Vb.NET 1, Java. Hay plantillas para usar Nhibernate, Hibernate, JSP, MySql, y conceptos de Domain-Driven Design. Todo desde el mismo modelo. Tomemos como muestra una plantilla, la que genera la entidad en Visual Basic, EntityVb.tpl:
<#
message "Generating Entity ${Entity.Name}"
include "Templates/VbNet2/VbFunctions.tpl"
include "Templates/VbNet2/Prologue.tpl"
#>
'
' Project ${Project.Name}
' ${Project.Description}
' Entity ${Entity.Name}
' ${Entity.Description}
'
'
Public Class ${Entity.Name}
' Private Fields
<# for each Property in Entity.Properties
message "Procesando Campo ${Property.Name}"
#>
Private m${Property.Name} as ${VbType(Property)}
<#
end for
#>
' Default Constructor
Public Sub New()
End Sub
' Public Properties
<#
for each Property in Entity.Properties
message "Procesando Propiedad ${Property.Name}"
#>
Public Property ${Property.Name}() as ${VbType(Property)}
Get
Return m${Property.Name}
End Get
Set(ByVal Value As ${VbType(Property)})
m${Property.Name} = Value
End Set
End Property
<#
end for
#>
End Class
Como antes, se usan estructuras de control, y recorrido de una entidad del modelo. No se maneja el XML. El formato XML es la forma de serialización del modelo. Durante el proceso de la plantilla, el modelo ya está en memoria, accesible desde variables dinámicas.
Los pasos
Ahora tenemos más archivos a generar: desde las páginas ASPX, y su código asociado, los proyectos de fachada de servicio, entidades, acceso a datos, el archivo de solución, y más. Para automatizar esta generación, el ejemplo tiene varios archivos de tareas, en el directorio Tasks, donde se describen los pasos a ejecutar. Hay dos grandes tareas: los pasos a ejecutar independientemente de la tecnología elegida, como completar el modelo, revisarlo, y las dependientes de la tecnología, como generar tal archivo JSP o ASPX, dependiendo de si queremos Java o .NET.
La tarea de completar el modelo está a cargo de Tasks\BuildProject.ajg, que comienza con:
'
' Build Project
' Complete the Project Data
' Project must be loaded in global variable Project
'
PrintLine "Completing Project ${Project.Name}"
include "Templates/EntityFunctions.tpl"
include "Templates/Utilities.tpl"
if not Project.Title then
Project.Title = Project.Name
end if
if not Project.Version then
Project.Version = "1.0.*"
end if
if not Project.SystemName then
Project.SystemName = Project.Name
end if
Acá incluye algunas funciones auxiliares, y luego comienza a completar el modelo que reside en la variable Project. Ejemplo: si falta Project.Title le coloca como título el Project.Name. Prosigue:
for each Entity in Project.Model.Entities
PrintLine "Entity " + Entity.Name
for each Property in Entity.Properties
PrintLine "Property " & Property.Name
if not Property.Description then
Property.Description = Property.Name
end if
if not Property.Title then
Property.Title = Property.Description
end if
if Property.Type="Id" and not Property.SqlType then
Property.SqlType="int"
end if
if Property.SqlType and not Property.SqlColumn then
Property.SqlColumn = Property.Name
end if
if Property.Type="Id" and not Entity.IdProperty then
Entity.IdProperty = Property
end if
if Property.Reference then
...
Mas adelante, se ejecutan las tareas de tecnología. Como ejemplo, veamos un fragmento de Tasks\BuildVbNet2.ajg:
<#
include "Templates/Utilities.tpl"
include "Templates/VbNet2/UtilitiesVb.tpl"
message "Creating Directories..."
FileManager.CreateDirectory(Project.BuildDir)
FileManager.CreateDirectory("${Project.BuildDir}/Sql")
FileManager.CreateDirectory("${Project.BuildDir}/Src/${Project.Name}.Entities")
FileManager.CreateDirectory("${Project.BuildDir}/Src/${Project.Name}.Entities/My Project")
FileManager.CreateDirectory("${Project.BuildDir}/Src/${Project.Name}.Data")
FileManager.CreateDirectory("${Project.BuildDir}/Src/${Project.Name}.Data/My Project")
FileManager.CreateDirectory("${Project.BuildDir}/Src/${Project.Name}.Services")
…
En este fragmento, se crean los directorios necesarios para albergar la solución. El nombre del directorio se extrae del modelo desde ${Project.BuildDir}.
Generando la solución
Podríamos lanzar las tareas desde la línea de comando, pero tenemos un build armado para el Nant, uno para cada tecnología. Ejecutamos las tareas build, buildsql, y deploysql de AjFirstExampleVbNet2.build:
En el directorio Build/AjFirstExample/VbNet2/Sql quedan los scripts de creación de la base y procedimientos almacenados. Y en el directorio hermano Src, sorpresa, tenemos la solución ya preparada:
Encontramos varios proyectos armados. Si levantamos la solución en el Visual Studio 2005, aparece todo el código generado:
Con otro archive build AjFirstExampleCSharp2.build, generamos la misma solución en CSharp:
Encontrarán otros proyectos y ejemplos de .build, que usan NHibernate, Hibernate, JSP, y conceptos de DDD.
Reflexiones
Claro, no todo se puede generar automáticamente. Es importante tener siempre presente esto. Pero en el día a día, reconozcamos que tenemos cantidad de texto repetitivo, tareas que bien podemos encargar al propio software.
Recordemos siempre: el modelo es libre. Los ejemplos presentados son solamente ejemplos: podemos general el modelo que queremos, y escribir las plantillas que necesitamos. Es importante escribir las plantillas de forma que el código generado sea similar al que hubiéramos generado nosotros. Si no nos sentimos cómodos con el código generado, si no tiene nuestro estilo, nuestra experiencia, terminamos generando algo que no entendemos.
Otra reflexión: el modelo debe ser independiente de la tecnología. En el ejemplo final, hemos visto cómo, desde el mismo modelo, se puede generar la solución para VB.NET2, y para CSharp. Encontrarán las plantillas para generarla con Nhibernate, con DDD, con Hibernate, con Java y JSP, y podemos escribir la que necesitamos.
El software debe ayudarnos a generar software. Nuestra experiencia cuenta: lo que aprendimos de hacer aplicaciones, podemos volcarlo en esta especie de sistema experto, generador de código. Justamente, en el futuro, espero poder incorporar al proyecto, en las plantillas, más toma de decisiones: así como volcamos nuestra experiencia en escritura de aplicaciones, podemos incorporar nuestro conocimiento acumulado sobre patrones, arquitectura, estilos de programación.
Y al ser de código abierto, AjGenesis permite que lo extendamos, a nuestro gusto y necesidad.
Se aceptan sugerencias, historias de uso. Pueden escribir comentarios a este artículo, o escribirme. Desde ya, muchas gracias por cualquier "feedback".
Nos leemos!
Angel "Java" Lopez
http://www.ajlopez.com/
Esta semana, la gente de Microsoft Latam está presentando eventos en línea. Por un lado, el eXpert Zone del Caribe:
http://www.mslatam.com/latam/expertzone/
Desde el 25 al 29 de Junio, hay conferencias para desarrolladores de software, y para la gente de IT. Son dos "tracks", uno para TechNet, y otro de MSDN. Hay 40 conferencias, y 10 sesiones de "Pregúntale al experto". Me temo que sin registración, no parece haber más información (como oradores, agenda y demás).
Por acá, en Cono Sur, tenemos las conferencias de:
http://www.microsoft.com/conosur/tercereventoonline/
Acá por lo menos, hay agenda disponible:
La Web 2.0 -Novedades y tendencias desde la perspectiva del desarrollador
Orador: Karina Leal
Conoce lo más innovador en tecnologías y herramientas Microsoft para explotar al máximo la web.
Conociendo System Center Operations Manager
Orador: Alberto Ortega
Nuestro Microsoft Operations Manager renace en System Center Operations Manager 2007. Veremos como mantener nuestra infraestructura saludable y controlada. Monitorear miles de eventos y condiciones en cientos de Sistemas Operativos y aplicaciones distintas con más de 50 management packs para lograr automatización de rutinas y tareas redundantes, incrementando la eficiencia a la vez que se tiene el control del ambiente IT.
Conociendo Virtual Machine Manager
Orador: Alejandro Ponicke
Sientes que te faltan herramientas para algunas tareas repetitivas y básicas? Ya no más, con las nuevas herramientas operativas de la suite System Center. En esta sesión revisaremos Virtual Machine Manager. Es la aplicación para la administración de un datacenter virtual que permite aumentar el uso de los servidores físicos al centralizar y virtualizar la infraestructura permitiendo, tanto a administradores como a usuarios finales, el proveer rápidamente nuevas máquinas virtuales.
Conociendo System Center Configuration Manager
Orador: Leandro Amore
Nuestro System Management Server renace en System Center Configuration Manager 2007. Veremos como optimizar la productividad y eficiencia reduciendo las tareas manuales y descentralizadas, obtener fácilmente inventarios de hardware, software y disponer del software necesario en el usuario preciso en el momento necesario, permitiendo administrar además servidores, estaciones de trabajo y dispositivos móviles.
Conociendo System Center Essentials
Orador: Leandro Sgallari
¿Tienes una empresa mediana y necesitas mantener el control de tu infraestructura? Essentials 2007 es una nueva solución de administración y control de infraestructura incluida en la nueva familia de System Center. Diseñado para Pymes, brinda una solución de administración unificada que permite a los profesionales administrar sus infraestructuras de manera proactiva y eficiente.
Implementación de ForeFront Client
Orador: Leandro Sgallari
Todo el poder de Forefront Client y su integración con Active Directory, que lo convierte en el antivirus más eficiente y operable del mercado. La nueva solución de Microsoft que asegura las estaciones de trabajo y servidores y que forma parte de una familia de antivirus nunca antes vista.
Conceptos básicos del modelo de programación web en .NET
Orador: Ángel López
Algunas demostraciones concretas de cómo resolver las tareas básicas, explotando las principales innovaciones de ASP.NET 2.0. Referencias al modelo de manejo de datos con ADO.NET y buenas prácticas de seguridad en el diseño y programación de sitios y aplicaciones web.
El nuevo mundo de las interfaces (WPF, WPF/E (SilverLight y Microsoft Expression)
Orador: Matías Bonaventura
Los usuarios requieren cada día más riqueza en las interfaces para el manejo de información. Un nuevo conjunto de tecnologías y herramientas desarrollados por Microsoft permiten a los desarrolladores de aplicaciones web obtener resultados increíbles de manera simple, posibilitando altos niveles de productividad.
Tengo una aplicación web en Visual Basic 6 ... ¿Cómo integro nuevas funcionalidades en Visual Basic .NET?
Orador: Esteban D'Annunzio
Una introducción a .NET para quienes crean sitios web y aplicaciones con Visual Basic 6.0. Lo que cambia en la programación, el acceso a datos y la arquitectura de los desarrollos, con explicaciones y demos. Básico para entender como agregar funcionalidad con tecnología de última generación.
Creación de un sitio web con .NET con costo cero
Orador: Martín Salas
Cómo armar sitios web en .NET usando C#, Visual Studio Web Developer Express Edition, SQL Express y DotNetNuke.
Cómo programar Workflow Foundation con Visual Studio dentro de Microsoft Office Sharepoint
Orador: Mauricio Grimberg
En esta charla veremos cómo es, cómo está implementado, para qué sirve y cómo podemos servirnos de Windows Workflow Foundation (WF). Después de la introducción, prepararemos la herramienta de desarrollo, apelando a las descargas necesarias, para crear un primer flujo de trabajo WF dentro de Office Sharepoint. Por último, avanzaremos en el modelo de objetos y en los controles específicos de Sharepoint, creando un flujo más avanzado utilizando listas. La charla será eminentemente práctica con los condimentos teóricos imprescindibles como para ponernos en tema.
Estan los buenos de Ortega, Ponicke, Salías, Grimberg..... y .... bue.... hay un tal Angel "Java" Lopez, que no se saca foto (habrá video y todo, de cada charla, con la mía, la gente de Dominio Digital hizo lo que pudo para que yo parezca humano...):
http://www.microsoft.com/conosur/tercereventoonline/oradores.aspx
Jejeje.... que caritas de viciosos... ;-)
Como desarrollador, todas son interesantes: me gustaría ver la charla del hiperactivo Bonaventura, sobre WPF, SilverLight y lo que se viene, o ver la de Workflow de Mauricio. La mía es apenas algo de ASP.NET 2.0, claro, con algún ejemplo generado por AjGenesis... no pude contenerme...
El martes tendré el gusto de compartir con el bueno de Martín Salías una conferencia en línea, de este evento.
Nos leemos!
Angel "Java" Lopez
http://www.ajlopez.com/
Todo lo que quería saber sobre Windows Presentation Foundation, la tecnología parte de .NET 3.x, ahora en la enciclopedia de WPF:
http://www.wpfpedia.com
creada y mantenida por Actipro Software, pero uno puede agregar sus propios enlaces.
What is WPFpedia.com?
WPFpedia.com is a free community resource that was created to provide an organized one-stop resource guide for Windows Presentation Foundation (WPF) developers.
There is a lot of great WPF-related information out on the web that developers have posted. However the problem used to be finding it. The WPFpedia.com resource guide solves this problem by providing a categorized list of links to various articles, blog posts, tools, and other resources throughout the web.
While the resource guide is updated by Actipro almost daily, we encourage you to add your own links as well. The resource guide currently contains 419 resource links.
Visit this site often or subscribe to the RSS newsfeed to keep on top of the latest WPF resources on the Internet.
Algunas categorías
Books, Tutorials and Help
Sample WPF Applications
Essential Tools
WPF Blogs
WPF Sample Code
Gracias a Ezequiel Jadib por el dato.
Nos leemos!
Angel "Java" Lopez
http://www.ajlopez.com/
Garret Serack de Microsoft, ha pasado al grupo Open Source Software Labs de la misma empresa. Aunque siempre he visto a ese grupo más orientado a relacionarse con proyectos Linux y demás, descuidando los proyectos de código abierto en .NET y Windows, veremos si ahora se puede esperar una actitud más abierta ....;-)
Más en el post de Garret:
Open Source at Microsoft -- Herdin' cats or Cow Chips?
Entre los puntos que plantea, para destacar:
- Seeking out Open Source projects we can assist (either by contributing code, MSDN licenses or whatever :D )
- Speaking/Presenting with companies, conferences, groups and people
- Building an Open Source MVP Program
- Enlightening Microsoft Product Groups about Open Source, and finding opportunities for them
- Facilitating communication between open source developers and Product Groups
- Building transparency into Microsoft and Open Source (believe it or not!)
There have been a lot of changes in Microsoft in the last few years, that folks can't yet see, and I'm hoping to expose that type of thing to the world, and bring the world of Open Source to Microsoft.
Interesante lo de Open Source MVP Program. Qué será?
Nos leemos!
Angel "Java" Lopez
http://www.ajlopez.com/
La gente de Redmond tiene una implementación interna de Scrum. No confundir con la de Conchango.
Ahora está disponible al público, con un template para usar dentro del Team Foundation Server:
eScrum is a Web-based, end-to-end project management tool for Scrum built on the Microsoft Visual Studio Team Foundation Server platform. It provides multiple ways to interact with your Scrum project: eScrum Web-based UI, Team Explorer, and Excel or Project, via Team Foundation Office Integration. In addition, it provides a single place for all Scrum artifacts such as product backlog, sprint backlog, task management, retrospective, and reports with built-in context sensitive help
Fuente: http://blogs.msdn.com/adamga/archive/2007/06/13/microsoft-escrum-version-1-0.aspx
Download: http://www.microsoft.com/downloads/details.aspx?familyid=55a4bde6-10a7-4c41-9938-f388c1ed15e9&displaylang=en&tm
Gracias al bueno de Ezequiel Jadib por el dato.
Una de mis películas entrañables en mi vida es "Volver al futuro". Ahora, pueden ver al mismísimo de Christopher Lloyd en una presentación del gigante de Redmond:
ORLANDO - In a very memorable effort to erase executive vice president Bob Muglia's reputation for overstating the "Microsoft Vision," while introducing a much-needed element of self-deprecating humor to the proceedings, the company's senior vice president starred with the legendary Christopher Lloyd in a "Back to the Future" video where he was given an opportunity to go back in time two years and undo the mistakes of his prior keynotes... [more]
Ver el video en:
http://www.microsoft.com/winme/0706/29992/teched_.asx
(fuente: el bueno de Mariano Szklanny)
Hace unos días, Microsoft lanzó una nueva forma de interactuar con la computadora, algo que estuvo preparando desde años, desde un proyecto de un equipo de investigación. Utilizan una pantalla con interacción con las manos, algo que ya vimos acá en otras interfaces.
Visiten el sitio
http://www.microsoft.com/surface/
donde cuentan las capacidades, las posibilidades, y, a mí me pareció muy interesante, los orígenes de este producto. Vean cómo hay un movimiento competitivo alrededor de este tipo de dispositivos. Veremos si son "the next big thing" o no. Creo que es fundamental, para la adopción de esa tecnología, dos puntos:
- la existencia de software que los aproveche
- un costo accesible
Por lo que ví de otras implementaciones, el hardware es accesible: es posible construirlo sin tener invertir en costosas investigaciones de nuevas tecnologías.
Veremos que sucede, por ahora, quiero uno para Navidad!! :-)
Gracias a Matías Woloski, que fue el primero en enviarme el enlace.
Nos leemos!
Angel "Java" Lopez
http://www.ajlopez.com/
Gracias a la organización del MUG de Argentina, la semana que visitaré la ciudad de Tandil, en el centro de mi provincia, Buenos Aires. Hace como tres décadas que no paso por ahí, pero igualmente poco voy a poder ver de la ciudad, porque llego temprano a la mañana y me vuelvo esa misma noche (tanto el martes como el jueves, tengo cursos en la ciudad de Buenos Aires).
Voy a dar una charla de cuatro horas, sobre ASP.NET, en la Universidad Nacional del Centro de la Provincia de Buenos Aires, en la Facultad de Ciencias Exactas (uau, espero encontrarme con estudiantes de matemáticas, pero no creo que estén interesados en programación) (vean cómo usan ahí en la Facultad al Sistema Guaraní, del SIU). Espero poder mostrar cómo es lo nuevo de ASP.NET 2.0, y explicar las extensiones de Ajax, entre otros temas. Seguro encontraré alguna "excusa" para mostrar algo de generación de código con AjGenesis... ;-)
Acá está el temario publicado:
Horario: de 14:00 a 18:00 hs
En ASP.NET 2.0 se mantiene el modelo de programación ASP.NET, que utiliza el framework de clases de .NET, y la generación de páginas dinámicas. Veremos los nuevos controles y conceptos que tiene la versión 2.0, incluyendo Ajax.
Contenidos:
Modelo de programación con ASP.NET
Nuevos controles en ASP.NET 2.0
El control GridView
Otros controles enlazados a datos y objetos
Autenticación y Autorización
Master Pages
Themes
Skins
Web Parts y personalización
Ajax en ASP.NET: actualizando partes de la página
Nivel: Basico e intermedio.
Más información, e inscripción, en:
http://www.mug.org.ar/Eventos/2687.aspx
Como siempre, el material (algunos ejemplos, enlaces), quedará publicado en http://www.ajlopez.com/
Más información sobre Tandil en:
http://www.welcomeargentina.com/tandil/index_i.html
http://www.tandilnet.com/
http://www.cybertandil.com.ar/turismo/index.htm
Nos leemos!
Angel "Java" Lopez
http://www.ajlopez.com/
Hay un libro que me gustaría recomendar desde acá: "The Pragmatic Programmer" de Andrew Hunt y David Thomas. Excelente recurso para todo aquel que se dedique al desarrollo del software. En otro post comentaré la estructura del libro. Más sobre su contenido en su sitio:
http://www.pragmaticprogrammer.com/
¿Cómo es un programador pragmático? ¿A quién está dirigido este libro? A los que quieren transformarse cada día en mejores programadores. Los autores enumeran algunas características de lo que llama un programador pragmático:
- "Early adopter/Fast adapter": tiene un gusto por la tecnología, le gusta entender las cosas. Ante algo nuevo, lo aprehenden, lo atrapan, lo entienden, rápidamente, y lo integran al resto de su conocimiento. Tienen confianza, nacida de la experiencia.
- Inquisitivo: Tiende a hacer preguntas. Quiere saber cómo funciona tal rutina o programa. Acumula respuestas, hechos, que pueden servir ahora o dentro de años.
- Pensador crítico: No acepta las cosas, la tecnología, sin antes explorar los hechos. No hace algo sólo porque sea "la forma de hacerlo".
- Realista: Trata de entender la naturaleza que hay abajo de cada problema que enfrenta. Ese realismo le da un buen sentido de cuán difícil es alguna cosa, o cúanto tiempo llevará hacerlo. Al comprender lo difícil o largo que puede ser un proceso, sabe mantenerse en camino.
- "Jack of all trades": Se esfuerza para familiarizarse con un amplio rango de tecnologías y ambientes, sistemas operativos y lenguajes, utilitarios y metodologías. Aunque su trabajo actual sea el de un especialista, siempre busca moverse y aprender nuevas cosas.
Pero la principal característica que los autores destacan, es lo que llaman el "tip 1" (van enumerando y comentando tips a lo largo de toda la obra):
Care about your craft: Se toman el trabajo de interesarse en lo que hacen, en esmerarse en la obra que están creando.
Y el "tip 2" es uno de mis preferidos:
Think! About your work. Pensar, siempre pensar, en especial sobre el trabajo que hacemos. Siempre tratar de meditar, entender, ver más allá de la técnica, buscar las razones, discutirlas, exponerlas a la luz y a la crítica.
Espero tener alguna de estas características, y otras practicarlas hasta adquirirlas. Y Uds, cómo se ven ante esta lista?
Nos leemos!
Angel "Java" Lopez
http://www.ajlopez.com/
En el siglo pasado (cómo pasan los años), alguna vez estuve estudiando Squeak. En estos días he vuelto a visitarlo, y quería escribir un artículo simple, introductorio, sobre su fácil instalación.
Squeak es una implementación de código abierto de Smalltalk, que ha venido desarrollándose desde hace años. Es interesante la implementación interna de su máquina virtual, en gran parte escrita en Smalltalk, con herramientas para producir su propia máquina virtual.
Como en otras implementaciones, uno necesita instalar la máquina virtual del sistema operativo que usará. En este artículo, instalaremos una versión (la 3.9) para Windows. También necesitaremos una imagen, un archivo con el estado de las instancias activas. Smalltalk se ha caracterizado desde siempre, por poder escribir y levantar una imagen, una especie de "snapshot" del estado del sistema.
La página de Squeak es
http://www.squeak.org
Para alguien no avisado de la existencia de máquinas virtuales e imágenes, es un poco confusa la explicación de su instalación:
http://www.squeak.org/Download/
porque hay varias opciones. Por ejemplo, bajar las versiones desde
http://ftp.squeak.org
Pero hay multitud de archivos. El que vamos a usar es un archivo .zip que contiene la máquina virtual para Windows y la imagen 3.9 (actualmente ya hay una imagen 3.10 en desarrollo), directamente desde:
http://ftp.squeak.org/3.9/win/Squeak3.9-win32.zip
Ese archivo contiene:
Vemos un Squeak.exe, que es la máquina virtual ejecutable. El archivo SqueakV39.sources es de texto, de más de 4 megas de tamaño. Contiene el código fuente de las clases que componen esta versión. El archivo Squeak3.9-final-7067.image es la imagen, el "snapshot" que contiene las instancias de este sistema.
Podemos expandir el contenido de este .zip en un directorio, y hacer doble click sobre el ejecutable de la máquina virtual Squeak.exe. Automáticamente detecta la imagen. Alternativamente, podríamos arrastrar desde el Explorer de Windows el archivo imagen sobre el archivo .exe. Aparece nuestra primer bienvenida al mundo Squeak:
Todo lo que aparezca dentro de esta ventana, es armado por el propio Squeak. Siguiendo la tradición del Smalltalk original, el aspecto gráfico, los controles, ventanas, y demás "widgets" son dibujados por el propio sistema. La apariencia de esta ventana y sus contenidos, entonces, es independiente del sistema operativo.
En la solapa derecha titulada tools, encontramos una serie de herramientas. Levantando el clásico "browser" de Smalltalk, encontramos:
Las cuatro listas superiores, muestran, en orden:
- Las categorías de clases
- Las clases de la categoría seleccionada
- Las categorías de métodos (de instancia o de clase)
- Los métodos
En la captura de pantalla aparece la clásica Object, de Kernel-Objects.
Los interesados en la máquina virtual, pueden visitar
http://www.squeakvm.org
Es interesante ver las instrucciones para producir una máquina virtual, por ejemplo, en Win32:
http://www.squeakvm.org/win32/compiling.html
Bueno, por hoy, bastante. Espero que les sirva para comenzar a conocer e investigar esta implementación de Smalltalk.
Nos leemos!
Angel "Java" Lopez
http://www.ajlopez.com/