on miércoles, 17 de octubre de 2012


Muy buen día, el día de hoy trabajaremos con la clase List de c#.

Dicha clase es una plantilla para todos los tipos, es decir podemos hacer una instancia de una lista de diferentes tipos, por ejemplo.


List<int> listaDeEnteros = new List<int>(); 

Así es como declaramos una lista de enteros. Este tipo de listas son bastantes útiles a la hora de estar desarrollando en c#, ya que son altamente usables.

Y aquí esta un ejemplo de como se llena una lista y como se recorre.


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            List<int> listaDeEnteros = new List<int>();

            for (int i = 1; i <= 20; i++)
            {
                listaDeEnteros.Add(i);
            }

            foreach (int entero in listaDeEnteros)
            {
                Console.WriteLine(entero);
            }

            Console.ReadKey();
        }
    }
}
 

Este tipo de listas, como son una plantilla, se pueden usar todos los tipos de datos primitivos como clases hechas por el desarrollador, a continuación trataremos estas listas ya con objetos.

Supongamos que tenemos una lista de clientes con una propiedad nombre y otra que indica si el cliente es moroso o deudor, como quieran llamarle.


Es necesario crear la clase:
 


class Cliente
{
   public string Nombre { get; set; }

   public bool EsMoroso { get; set; }

   public Cliente()
   {

   }

   public Cliente(string nombre, bool esMoroso)
   {
       this.Nombre = nombre;
       this.EsMoroso = esMoroso;
   }
}


Ahora bien, creamos una lista de clientes.

List<Cliente> clientes = new List<Cliente>();

Ahora creamos 5 clientes, al inicio ninguno de ellos sera moroso.

Cliente cliente;

for (int i = 0; i < 5; i++)
{
cliente = new Cliente("cliente No. " + i + 1, false);
clientes.Add(cliente);
}

Las lista puden acceder a cualquiera de sus ítems dentro de su colección.
Por ejemplo, vamos hacer moroso a dos clientes.

clientes[2].EsMoroso = true;
clientes[3].EsMoroso = true;

Por lo tanto es necesario crear una nueva lista que contenga a todos los clientes morosos.

List<Cliente> clientesMorosos = new List<Cliente>();

Hecho esto, tenemos que recorrer toda la lista de clientes y obtener todos aquellos clientes que son deudores.
 

foreach (Cliente cliente in clientes)
{
   if (cliente.EsMoroso)
   {
        clientesMorosos.Add(cliente);
   }
}



Y ahora los mostramos en pantalla.

foreach (Cliente clienteMoroso in clientesMorosos)
{
    Console.WriteLine("El cliente "+clienteMoroso.Nombre +" Es un deudor, favor de               no autorizarle el credito solicitado");
}

Como estamos recorriendo la lista de clientes morosos, estamos asegurando que todos los clientes que se encuentren dentro de esa lista, son deudores.
 

 
on jueves, 11 de octubre de 2012
Hay todo un dilema cuando un proyecto de software va mal, y es que en algunos casos si no es que en la mayoría (en mi caso en la mayoría así lo ha sido) le quieren echar la culpa al desarrollador y los administrativos no toman su responsabilidad.

Resulta que cuando se lleva a cabo un desarrollo, se tienen que contemplar los riesgos que conlleva llevar dicho proyecto, si no se toman las medidas necesarias para detectar a tiempo dichos riesgos, el proyecto podría tener retrasos e incluso que nunca llegue a producción.

Cuando un desarrollador novato entra en una consultora, tiende a pensar que si no sale el proyecto es por su culpa (experiencia personal y comentarios de compañeros), con lo cual llegan a quedarse una o dos o incluso mas tiempo trabajando para sacar a tiempo el proyecto.

¿Pero que pasa con los administradores del proyecto?
Porque ese afán de culpar al desarrollador de que el proyecto va mal, y hacerlo sentir mal y sin mas remedio condenarlo a quedarse tiempo extra vendiéndole que si no cumple con su trabajo lo corren.
A mi humilde punto de vista es una manera muy fatalista de aprovecharse de la necesidad de los desarrolladores.

Bueno, antes de continuar, ¿quienes son los mentados administradores?

Pueden ser, la gerencia, el líder de proyecto, el arquitecto de software, recursos humanos, el proyect manager, el product owner, el scrum master (si es que se usa scrum como metodología de gestión de proyectos), incluso si se tiene un líder técnico muy arrogante y ególatra, podrá ser que nos culpen cuando un proyecto va mal.

Recordando un poco el libro de ing. De software de Braude (1), les muestro los factores de riesgo en orden de importancia.

1. Falta de compromiso de la alta administración.
2. Falla al obtener el compromiso del usuario.
3. Error al entender los requerimientos.
4. Participación inadecuada del usuario.
5. Falla al manejar las expectativas del usuario final.
6. Cambio de alcance y/o de objetivos.
7. Falta de conocimientos o aptitudes requeridas del personal.

Como lo pueden notar, el desarrollador es el que menos tiene la culpa de que un proyecto ande mal, como bien lo dice Braude, la falta de compromiso de la alta administración es el principal riesgo para que un proyecto salga mal.

O el del líder de proyecto, que no entienda lo que en realidad pide el usuario final, y a nosotros los desarrolladores nos ponen hacer cosas que desde el levantamiento de requerimientos están mal.
O también no falta que vamos en una etapa avanzada del proyecto y nos cambian los requerimientos.
A pero eso si, el desarrollador tiene la culpa por que prever esos cambios de los requerimientos es su trabajo por que el lo esta desarrollando.

Todo esto hace que me pregunte lo siguiente:

¿Dónde esta el rol de los administradores del proyecto?

(1)
Ingeniería de software. Una perspectiva orientada a objetos
Capitulo 2 Administración de proyectos.
Braude.

on miércoles, 10 de octubre de 2012


Muy buen día, hace mucho tiempo sin escribir nada en el blog, el detalle fue que al cambiar de trabajo y de ciudad se presentan ciertos inconvenientes como el no tener internet en la casa y tener el internet restringido en la nueva consultora. En fin, espero darme el tiempo necesario para poder seguir compartiendo nuevas vivencias y compartir los consejos de mis maestros del mundo del desarrollo de software.

En la consultora estamos trabajando con .net en el lenguaje c# y la tecnología de WPF y WCF, algunos de mis compañeros son nuevos en el lenguaje de c#, y e aprendido que es necesario pasar por ciertas fases para poder dominar dicho lenguaje, a continuación presento una serie de puntos secuenciales que son necesarios para dominar no solo c# si no cualquier lenguaje de programación que se pueda presentar.
  

  •  Conocer la mayoría de las palabras reservadas y la sintaxis del mismo.


  • Conocer las primitivas de código en programación orientada a objetos (clases, objetos, herencia, polimorfismo, encapsulación, abstracción, introspección y reflexión).

  •  Conocer el manejo de eventos en c#.

  •  Implementación de patrones de diseño según el contexto que lo ameriten.

  •  Conocer los estándares manejados para que la comprensión del código sea legible.
on martes, 10 de julio de 2012

Que tal, ahora veremos cómo cambiar de color las celdas de una tabla en html con jquery.
Para comenzar a trabajar con jquery tenemos que descargarnos la librería de aquí: http://code.jquery.com/jquery-1.7.2.min.js

Una vez que tengamos la librería, la guardamos en una carpeta común donde estará nuestra página html y nuestro archivo de javascript (.js).

Comenzando con el código, crearemos la siguiente pagina web: 


<html>
    <head>
        <title> pintando celdas en una tabla con jquery</title>
        <script type="text/javascript" src="jquery-1.7.2.min.js"> </script>
        <script type="text/javascript" src="selector.js"> </script>
    </head>
    <body>
        <table id="tabla1"  border="1">
            <tr>
                <td> Juan </td>
                <td> Flor </td>
                <td> Maria </td>
                <td> Fernando </td>
            </tr>
            <tr>
                <td> Carlos </td>
                <td> Alfredo </td>
                <td> Jose </td>
                <td> Gaby </td>
            </tr>
            <tr>
                <td> Alan </td>
                <td> Nayeli </td>
                <td> Nicolas </td>
                <td> Jessica </td>
            </tr>
        </table>
    </body>
</html>

una parte importante es cuando registramos un script, y en la parte del head de nuestra pagina tenemos los siguientes scripts registrados:


<script type="text/javascript" src="jquery-1.7.2.min.js"> </script>
<script type="text/javascript" src="selector.js"> </script>

uno es la libreria jquery y el otro es nuestro codigo de javascript donde esta el codigo de jquery para pintar de color las celdas.


el codigo del archivo js es el siguiente:


var x;
x=$(document)
x.ready(inicializarEventos);

function inicializarEventos()
{
    var x;
    x= $("#tabla1 td");
    x.click(cambiaColor);    
}

function cambiaColor()
{
    var x;
    x=$(this);
    x.css("background-color","ff00ff");
}

es necesario que se llame selector.js por que así fue definido en el script de la pagina html, si no no va a funcionar.


ahora solo basta ejecutar nuestra pagina web.



Que tal, en esta ocasión veremos las variables de sesión en asp.net con c#.

Realmente una vez entendido el concepto de lo que son las variables de sesión, aplicarlo en .net será sumamente sencillo.

Pues bien, para poder accesar a un sitio web que tiene una cierta seguridad en cuanto al contenido de la web, es necesario autenticarnos al sitio para poder verlo, una vez que nos autenticamos al sitio se genera una variable de sesión donde se puede guardar información del usuario que ha sido autenticado.

En ASP.net es sumamente fácil manipular las variables de sesión. En el ejemplo que pondré a continuación se mostrara el ejemplo de cómo asignar y manipular una variable de sesión.

Entonces basta de charlas y mas acción. A continuación el ejemplo del código:

 using System; 
 using System.Collections.Generic; 
 using System.Linq; 
 using System.Web; 
 using System.Web.UI; 
 using System.Web.UI.WebControls; 
 public partial class _Default : System.Web.UI.Page 
 { 
   protected void Page_Load(object sender, EventArgs e) 
   { 
     HttpContext.Current.Session.Timeout = 30; 
     HttpContext.Current.Session["idCliente"] = 123; 
     int idCliente = int.Parse(HttpContext.Current.Session["idCliente"].ToString()); 
     Response.Write("<script type=\"text/javascript\"> alert(\""+idCliente+"\") </script>"); 
   } 
 } 


la sesion se encuentra en la clase HttpContext como lo podemos ver:  HttpContext.Current.Session



dicho objeto tiene una serie de propiedad importantes, una de ellas es el: Session.Timeout, la propiedad Timeout es para indicarle en cuanto tiempo se desea destruir la sesión.


como podemos ver en la siguiente linea:


         HttpContext.Current.Session["idCliente"] = 123;


nuestra propiedad de sesión contiene una arreglo de variables de sesión, para agregarlas basta con definir el nombre de nuestra variable y asignarles un valor.


Cabe destacar que podemos asignarle cualquier tipo de dato ya que es de tipo object, y para recuperarla tendremos que hacerle un cast en cas de trabajar con un objeto o un convert o un parse dependiendo si es un tipo de dato primitivo como un entero.


para recuperar nuestra variable de sesion basta con la siguiente linea:


     int idCliente = int.Parse(HttpContext.Current.Session["idCliente"].ToString());


y ya por ultimo, mostramos el valor de nuestra variable de sesión mediante el metodo Write() de la clase Response:

     Response.Write("<script type=\"text/javascript\"> alert(\""+idCliente+"\") </script>");  

Espero les sea de utilidad esta información, que pasen bonito día 
=)


on viernes, 22 de junio de 2012
Que tal, en esta ocasión les traigo una colección de fractales que diseñe ya hace tiempo con el fractal forge.


psicodelia2



psicodelia4



psicodelia5


Xaos1


Xaos3


Xaos4

enjoy ;)
on lunes, 21 de mayo de 2012
Teniendo siempre presente que la vida es como el Tetris: los éxitos desaparecen, los fracasos se acumulan

Frase de Javier Garzás.

sitio: http://www.javiergarzas.com/
Que tal, ayer por la noche, mientras veian la final del fut, me encontre con un blog super interesante, todos sus post (o al menos los que vi en su momento) estan relacionado a la ingeniería software, calidad software, procesos, normas, metodologías agiles, externalización IT y cosas relacionadas a la temática.

stio web: http://www.javiergarzas.com