Estimados amigos:

Si bien me he demorado en realizar una nueva entrada en este blog, es un exelente momento para que comparta con ustedes los resultados de una nueva investigación que realicé sobre animaciones en Silverlight: como hacer una animación armada por código con continuidad perpetua.

He aquí el codigo:

- Page.xaml

<UserControl x:Class=”Circle.Page”
xmlns=”http://schemas.microsoft.com/winfx/2006/xaml/presentation“
xmlns:x=”http://schemas.microsoft.com/winfx/2006/xaml“
Width=”640″ Height=”480″>
<Grid x:Name=”LayoutRoot” Background=”White”>
<Path Fill=”Blue”>
<Path.Data>
<EllipseGeometry x:Name=”ellipse”
Center=”320,240″ RadiusX=”5″ RadiusY=”5″ />
</Path.Data>
</Path>
</Grid>
</UserControl>

- Page.xaml.cs

using …;

namespace Circle
{
public partial class Page : UserControl
{
const int rpm = 2;
const int frameTime = 1000/30; // in milliseconds;
Duration frameDuration = new Duration(TimeSpan.FromMilliseconds(frameTime));
double angle = 0.0;
double radius = 200;
double angleDelta = 0.1;
Point beforePoint = new Point();
Storyboard storyBoard = new Storyboard();
PointAnimation animation = new PointAnimation();

public Page()
{
InitializeComponent();

Loaded += new RoutedEventHandler(Page_Loaded);
}

void Page_Loaded(object sender, RoutedEventArgs e)
{
InitStoryBoard();
}

private void InitStoryBoard()
{
animation.BeginTime = new TimeSpan(0);
animation.Duration = frameDuration;
storyBoard.Children.Add(animation);

Storyboard.SetTarget(animation, ellipse);
Storyboard.SetTargetProperty(animation, new PropertyPath(“Center”));

storyBoard.Duration = frameDuration;
LayoutRoot.Resources.Add(“story”, storyBoard);
storyBoard.Completed += new EventHandler(storyBoard_Completed);

NextSequence();
storyBoard.Begin();
}

void storyBoard_Completed(object sender, EventArgs e)
{
storyBoard.Stop();
NextSequence();
storyBoard.Begin();
}

private void NextSequence()
{
double newX;
double newY;

angle += angleDelta;
newX = this.Width / 2 + radius * Math.Cos(angle);
newY = this.Height / 2 + radius * Math.Sin(angle);

animation.From = beforePoint;
animation.To = new Point(newX, newY);
beforePoint = (Point)animation.To;
}

}
}

Este código fue probado en Windows XP, Visual Studio 2008, Silverlight Tool Kit 2.0.

Espero les sirva.

Saludos. Marcelo.

Estimados amigos: luego de estudiar un poco al mundo del código abierto y del cerrado, hago una sencilla conclusión:

- Los proyectos rápidos, simples y sin exigencias de calidad sólo tendrían cabida en el mundo cerrado, ya que de esa forma se mantienen costos bajos y rápida amortización.

- Los proyectos lentos, complejos y de alta calidad sólo tendrían cabida en el mundo abierto, ya que el costo es disminuido a su mínima expresión (aunque no gratis) y se permite el ingreso de mucho conocimiento y experiencia de muchos desarrolladores y usuarios.

Debo admitir que muchas veces he hablado mal de las personas que sólo copian entradas de blog de otras personas. Si bien podría ahora ocupar el lugar de esas personas, este texto que leí en este sitio, no podía estar excluido de mi blog ya que es un fiel reflejo de uno del sentimientos que es motor de mi persona:

“Una de las cosas que más me cuesta explicar a la gente no informática con la que me relaciono es la sensación que tienes cuando oyes la llamada del código.

Suele suceder cuando llevas un tiempo sin programar. Puede que durante ese tiempo hayas estado con ordenadores durante diez horas al día, navegando, administrando, leyendo… pero no programando.

Entonces un día, sin previo aviso, te entra el gusanillo. Tienes una idea o decides llevar adelante un proyecto que tenías aplazado y comienza la vorágine.

Al principio, con fiebre extrema, pasas horas aprisionado delante de la pantalla, el teclado echa humo y desarrollas líneas de código a toda velocidad. El síntoma principal es el insomnio, normalmente la fiebre te entra a primeras horas de la noche, y no vas a perder el tiempo durmiendo o cenando. Las únicas distracciones que te permites son levantarte a preparar una cafetera, ya que otro síntoma es el consumo de bebidas estimulantes. Cierras el irc, el jabber, el correo y los feeds por leer se acumulan, todo lo que te pueda distraer es eliminado y solo tienes un objetivo: el código.

La siguiente fase es la de reorganización. En un momento dado te das cuenta que tu mente va más deprisa que el código que generas, antes de entrar en esta fase es al revés, y que deberías parar un momento a generar un código más eficiente, más portable, más legible, algo más estandarizado y que incluso un subversión te vendría bien. Al final pasas del subversion por el tiempo que te llevaría leer tres páginas de documentación y sufres del clásico síntoma de libreritis. Empiezas a organizar clases en librerias, creas apis, renombras variables y desgastas dos milímetros las teclas de copiar y pegar.

La tercera fase es la del piño. Te quedas atascado con un problema, ya que al único que compilan los programas a la primera es a Chuck Norris. Un fallo que no encuentras, una situación que no te habías planteado o cualquiera de los múltiples poltergaist que se encuentra un programador. Llenas el código de printfs, de asignaciones de variables y juras en arameo. Al llegar a esta fase, si no vives solo, tu pareja percibe que no te ha visto últimamente y decide venir a empreñarte con tonterías como “¿qué haces?” o “¿qué te pasa?” justo a mitad de una sesión de debug.

Esta fase se puede prolongar en el tiempo y tu nivel de cabreo sube de forma exponencial, además tu pareja también se cabrea contigo diciendo que la ignoras, que la chillas y que además hay que ir al super para hacer la compra. La mayoría de divorcios de programadores son provocados por una mala asignación de valores no detectada.

Poco a poco el cabreo se te va pasando, pero el interés por el programa bloqueado también, es en ese momento cuando vuelves a la vida real. Empiezas con las comidas a las horas que toca, ves algo de televisión, incluso duermes, pero… no del todo.

El problema se ha quedado incrustado en tu cerebro en segundo plano, si te concentras un poco incluso le oyes dar vueltas por ahí dentro, y precedido por un toque de trompetas aparece la solución al jodido bug. Da igual lo que estés haciendo o la hora que sea, normalmente las tres de la mañana, vas corriendo al ordenador y tienes una recaída de la fiebre inicial y entre gritos y exclamaciones varias descubres que funciona.

Por último tienes el subidón, terminas el programa y la cosa funciona. Buscas gente a quien contárselo, si el programa es complejo te das cuenta de lo bueno que eres y te cuelgas medallas. Caminas por la calle con una sonrisa de oreja a oreja y cuando la gente te mira lamentas que ellos no sepan todo lo que tú has hecho, pero el subidón se pasa y vuelves al letargo. Volverá a pasar un tiempo hasta que tengas tú idea o que el proyecto te apasione y mientras tanto pasaras las horas con tu ordenador esperando, ¿deseando?, que vuelva esa sensación.

En resumen, no se si un programador es un yonki, que tiene que meterse su dosis para tener el subidón de forma periódica, o un enfermo crónico con recaídas en su enfermedad. ¿tú que piensas?”

Durante mi periodo de estudio universitario, varias veces la palabra calidad llegó a mis oídos y incluso debí estudiarla desde muchas fuentes de información. Casi todas las definiciones diferían, así que decidí armar mi propia definición:

“Calidad: es la satisfacción de la/s necesidad/es tanto inmediata como permanente, tanto actual como futura, del cliente, tanto externo como interno”.

Estimados amigos: Voy a explicar rápidamente como compartir carpetas entre computadoras con Windows y otras con Ubuntu Hardy Heron. Han cambiado algunas cosas desde Gutsy, por ello digamos que los “howto” necesitan una actualización:

Antes que nada necesitamos tener privilegios de administración del sistema, sino no podremos hacer nada de los que sigue.

- Abrimos terminal y escribimos lo siguiente:

$ sudo nautilus

- Buscamos la carpeta que queremos compartir

- Accedemos a las propiedades de esa carpeta, con click derecho sobre la carpeta -> propiedades.

- Vamos a la lengüeta Compartir.

- Chequeamos en “Compartir esta carpeta”

- Le damos el nombre con el cual la carpeta se verá en la red.

- Clic en el botón “Crear compartición”.

- Si no tienes instalado samba, te preguntara si lo quieres descargar. Se lo permitimos y se descargará.

- Una vez instalado lo recién descargado, nuevamente en el terminal escribís:

$ sudo gedit /etc/samba/smb.conf

- En gedit, buscamos la linea en la que dice “workgroup = WORKGROUP”, y reemplazamos WORKGROUP por el nombre del grupo de trabajo en que están configuradas las maquina que tienen Windows.

- Guardamos y cerramos.

- En el terminal escribimos:

$ sudo /etc/init.d/samba restart

- Por ultimo, habilitamos a los usuarios que tendrán acceso a las carpetas con:

$ sudo smbpasswd -a <USUARIO>

reemplazando <USUARIO> por el nombre de usuario local.

- Nos pedirá una password que se usara cuando este usuario acceda a través de la red. Sugiero que sea el mismo con el que se “loguee” pero lo dejo a tu criterio.

- En las computadoras con Windows vamos a Entorno de red -> Equipos cercanos y en teoría tendría que estar visible la compu con Ubuntu que tiene las nuevas carpetas compartidas.

Espero les sirva. Esto es mas que nada para darle la receta fácil y sencilla.

Buena suerte.

Estimados Amigos:

He publicado el código de lineDOC bajo licencia GPLv3. http://linedoc.ofingo.com/acercade/acercade.html

Aun no he armado el escenario para dar completo soporte a un proyecto de codigo abierto, pero estaré apuntando a ello de manera que lineDOC crezca sin inpedimentos.

Voy a recibir ideas, reportes de bug, pedidos de soporte en mi dirección personla de correo.

Espero al mundo le sea util lineDOC. Gracias y hasta luego.

Habiendo visto uin poco mas de blogs por ahi, me tope con el hecho que Blogger no es libre.

Estoy tomando como principio personal para mi futura carrera profesional, trabajar en la mayor medida posible con herramientas o servicios libres y aportar a ellos.

Asi que lo siento Blogger y bienvenido WordPress.

Estimados amigos: Luego de poner en funcionamiento lineDOC e intentando darle una vuelta de rosca para poder competir contra wikipedia, concluyo que la desarrollo web no es tan sencillo.

Existen muchas cosas a la hora de armar una pagina web:
- Objetivo
- Diseño visual.
- Diseño funcional
- Flexibilidad
- Velocidad de respuesta
- Compatibilidad entre navegadores. (Siempre pensar en que IE es especial)
- Mantenimiento.

Todo eso debe estar bien armado y equilibrado para poder tener exito.

Esto mas que nada está dirigido a aquellas personas de la informatica que dicen que no quieren estudiar informatica para estar haciendo “paginitas”.

A todos ellor, armen una pagina con calidad profesional y luego me cuentas…

Luego de revisar el viejo código de lineDOC encontré un problema clásico en la programación de pagina web dinámicas: registro y manejo de variables de sesión.

El método que estaba utilizando era:
- iniciar la sesión con session_start()
- registrar una variables con session_register(‘a’)
- y utilizar la variable con $a

Eso era útil pero se requería que register_global estuviera habilitado, que por defecto en la versiones de PHP 4.0.3 en adelante no es cierto.

La forma actual en la que se manejan las variables de sesión es a través del vector “superglobal” _SESSION, del siguiente modo:
- iniciar la sesión con session_start()
- asignar un valor a $_SESSION['a']
- y utilizar $_SESSION['a'] como una variable cualquiera que estará disponible en toda la sesión, incluso entre cambios de paginas.

Espero haya sido útil. Nos vemos.

Tengo el agrado de comentarles que lineDOC está nuevamente en linea, aunque aun está en proceso de puesta en marcha.

La direccion es linedoc.ofingo.com