¿Por qué programamos?

Es una pregunta que deberíamos hacernos antes de empezar a estudiar y/o aprender programación. La pregunta parece tan sencilla y compleja a la vez.

¿Por qué programamos? Algunos dirán que programamos porque nos pagan, otros porque les parece muy divertido y otros más divagarán en sus respuestas.

Tal vez la respuesta más lógica (y adecuada) es porque necesitamos resolver problemas. Es obvio que estos problemas tienen que ver con las empresas o centros de trabajo donde estamos. Donde se nos paga por crear programas o depurar proyectos existentes.

También existen personas que programan porque les motiva a crear cosas y no necesariamente estudiaron computación (o algo relacionado con las computadoras).  Así como hay gente que programa aunque no les guste (sic). 

Con el tiempo "el gusto de programar" puede terminar; gente que es muy buena programando y resolviendo problemas relativos a la programación, pero que termina odiando su trabajo.

Los que nos dedicamos a la programación debemos entender que no todos sabemos de todo, algunas cosas nos parecerán muy sencillas y otras nos provocaran mucha frustración al no poder resolverlas lo más rápido posible.

También la frustración de usar un lenguaje o herramienta que no nos guste, por ejemplo, usar Visual Studio (con C#) en lugar de Java o Python con Eclipse o cualquier otro IDE; las fechas de entrega de proyectos, las desveladas, no tener vida social, soportar personas que no nos agradan, etc..

A veces tienes que trabajar con gente que no tiene idea de lo que es la programación e ignora cual es tu trabajo, o peor  que ni el mismo tiene idea de lo que él hace ahí.  Su jefe inmediato le pide que ponga a trabajar a los de sistemas. ¿En qué? Ni él mismo lo sabe, solo hace lo que le pidieron.

En los comics de Dilbert se puede ver cada situación que viven los programadores, lo manejan de una manera muy sarcástica, pero aunque parezca exagerado no dista mucho de la realidad.

Para concluir, programamos porque necesitamos resolver problemas de la gente, por ejemplo, diseñar un programa para los cajeros automáticos, hacer que la interfaz sea lo más sencilla para el usuario final (aunque esta comprobado que eso no ayuda mucho, ya que la gente muchas veces no sabe usarlos aunque solo consista en apretar unos cuantos botones).

Programando en Java ... no. 9

Acaba de salir la nueva versión de la librería NiconNotify OSD , la cual provee clases para crear mensajes tipo "alert" de Java Swing.

Un ejemplo.

import javax.swing.UIManager;
import javax.swing.plaf.nimbus.NimbusLookAndFeel;

import nicon.notify.core.Notification;

public class TestNiconNotify {

    public static void main(String[] args) {
        try{
            UIManager.setLookAndFeel(new NimbusLookAndFeel());
            int respuesta=Notification.windowConfirmMessage(null, "Confirmacion", "Desea borrar Windows de sus sistema?");
            if(respuesta==1){
                Notification.windowMessage(null, "Respuesta", "Claro, quiero eliminar Windows de mi sistema");
            }else{
                Notification.windowMessage(null, "Respuesta", "No, todavia no.");
            }
           
        }catch(Exception ex){
            System.err.println("error: "+ex.getCause());
        }

    }

}

Ejecutando programa:

Programando en Java ... no. 8

Este ejercicio es muy sencillo, no es nada del otro mundo, crearemos una conexión a una base de datos MySQL, un método para insertar, actualizar, borrar y mostrar todos los datos de una tabla.

Herramientas:

• Eclipse Luna
• Librería  mysql-connector-java-5.1.34-bin.jar

Creamos la base de datos
create database test;

Creamos la tabla persona
create table persona(id int auto_increment primary key, nombre varchar(55),apellidoP varchar(55),apellidoM varchar(55),edad int, peso float,talla float);

Insertar valores a la tabla
insert into persona (nombre,apellidoP,apellidoM,edad,peso,talla) values ("Ernesto","Huerta","Flores",44,78.2,1.70), ("Mariana","Garcia",Torres",23,56.0,1.67);

Código de la conexión a la base de datos (Conexion.java)

La clase Persona.java tendrá las mismas propiedades de la tabla persona

public class Persona {
    private Integer id;
    private String nombre;
    private String apellidoP;
    private String apellidoM;
    private int edad;
    private Float peso;
    private Float talla;
   
    public Persona(){}

    //...demás métodos
}

Método para consultar los datos de la tabla

Método para crear persona

;

Método para actualizar persona

Método para eliminar persona

Julia en ejemplos no.2

En este ejemplo vamos veremos como introducir datos y crearemos una función para calcular el área de un triángulo equilátero.

1. Función para leer datos
2. Función para calcular área
3. Cuerpo principal del programa

#función para leer datos
function entrada(prompt::String="")
   print(prompt)
   chomp(readline())
end

#función para calcular área
function area(b,h)
  return (b*h) / 2.0
end

#cuerpo  principal del programa
begin
  run(`clear`)
  base=float(entrada("Introduce base:"))
  altura=float(entrada("Introduce altura:"))
  println("area obtenida: ",area(base,altura))
end


¿Cómo ejecuto el script?
julia nombreDeTuprograma.jl

Programando en Ceylon ... no. 4

Continuamos con la programación en Ceylon. En esta ocasión veremos un ejemplo de interfaces y clases abstractas.

Ejemplo. Programa que calcule el área de un triángulo, un cuadrado, y un circulo. 

Áreas (fórmulas):

Triángulo => (base*altura)/2 
Cuadrado => lado^2
Circulo => 3.14159*(radio^2)


Crearemos:

1. Una interface
2. Una clase base abstracta
3. Tres clases hijas

 ¿Cómo creo una interface en Ceylon?
 shared interface NombreInterface{ ... }

Llamaremos 'Operaciones' a nuestra interface, escribimos un método 'area', el cual nos servirá más adelante.

shared interface Operaciones{
   shared formal Float area();
}

Es muy similar a Java, aunque es obvio que las anotaciones y palabras reservadas van a cambiar.

La clase base abstracta quedará así:

abstract class Figura() of Triangulo|Cuadrado|Circulo satisfies Operaciones{ }

La parte  "of Triangulo|Cuadrado|Circulo"  nos indica las clases hijas, la parte "satisfies Operaciones" es similar al implements de Java.


Las clases hijas quedarán de la siguiente forma:
shared class Triangulo(base,altura) extends Figura(){
     shared Float base;
    shared Float altura;

    shared actual Float area(){
        return (base*altura)/2.0;
    }

    shared String description = "Triangulo(base: ``base``, altura: ``altura``)"; 
}
shared class Cuadrado(lado) extends Figura(){
shared Float lado;

    shared actual Float area(){
        return lado^2;
    }

    shared String description = "Cuadrado(lado: ``lado``)";

}
shared class Circulo(radio) extends Figura(){
  shared Float radio;

    shared actual Float area(){
        return 3.14159*(radio^2);
    }

    shared String description = "Circulo(radio:  ``radio``)"; 

}

Finalmente el método principal del programa.
shared void run(){

    Triangulo triangulo=Triangulo(12.9,20.0);
    Cuadrado cuadrado=Cuadrado(3.7);
    Circulo circulo=Circulo(2.9);
    print(" ``triangulo.description``");
    print(" ``cuadrado.description``");
    print(" ``circulo.description``");
    print(" area triangulo: ``triangulo.area()``");
    print(" area cuadrado: ``cuadrado.area()``");
    print(" area circulo: ``circulo.area()``");
}

Compilamos: ceylon compile source/elefante.ceylon
Ejecutamos: ceylon run default

Programando en C# no. 3 ...

Ingenieria económica en C#

Una alternativa para enseñar a programar es mediante ejemplos.  Tal vez a muchos no les interese para nada las matemáticas, sin embargo son necesarias en varios aspectos de nuestra vida.  Por ejemplo, a muchos de nosotros se nos complica la administración del dinero. Creemos que solo es para gastar, pero no es así. 

Planeamos comprar un auto, pagar deudas, etc. Sin embargo no tenemos un plan para hacerlo, y llegan los problemas. 

Preguntas como: 

• ¿Cuánto debo ahorrar para pagar mis estudios universitarios?
• ¿Es necesario conseguir una tarjeta de crédito? 
• Si pido un préstamo ¿Cuánto tendré que pagar después? 
• Etc.

No es indispensable contar con grandes cantidades de dinero o ser dueño de una empresa para poder administrar nuestro dinero. Tampoco ser experto en matemáticas financieras.

¿Qué es la ingeniería económica?
Es una colección  de técnicas matemáticas que simplifican las comparaciones económicas. 


Básicamente nos ayudan a tomar decisiones respecto al uso del dinero. 


Pasos para resolver problemas

1. Identificar el problema y entenderlo claramente
2. Definir las variables necesarias
3. Escribir los pasos necesarios para resolver el problema 
4. Convertir esa solución a código

Supongamos que pido una cantidad en préstamo a una tasa de interés fija y en un determinado plazo de pago, ¿Cuánto tendré que pagar al final de ese plazo?. 
 
Valor futuro

vf=vp*(1+n)**n


Esta fórmula nos sirve para obtener el valor futuro (vf) de esa cantidad en préstamo (vp) dado una tasa de interés (i) y un plazo de pago (n). Es la suma o valor  del dinero en algún futuro.

Ejemplo. María Isabel pide un préstamo de $ 12,000.00 a una tasa de interés del 3% y un plazo de pago de 4 años. Determinar el valor futuro de esa cantidad.

Paso 1: Identificar el problema.

Lo que nos pide es obtener el valor o suma de esa cantidad.

Paso2: Definir las variables necesarias.

vf=¿?

vp= $12,000.00

i= 3%

n= 4 años

Paso 3: Escribir los pasos necesarios para resolver el problema.

Realizamos el algoritmo. 
Calcular_ValorFuturo

Entrada: vp, i, n

Salida: vf  
Inicio

Escribe "Introducir monto inicial"
Lee vp
Escribe "Introducir tasa de interés"
Lee i 
Escribe "Plazo a pagar" 
Lee n 
Si (n>0 && i>0 && vp>0) entonces

    vf= vp * (1+i/100)**n 
fin_si 
otro
     Escribe  "no debe haber valores menores a cero"

fin_otro 
Escribe "El valor futuro es  %.2f"%(vf) 
Fin

Paso 4:  Convertir a código

En este caso usaremos C#, es necesario tenerlo instalado. Creamos un nuevo proyecto de tipo Windows Forms.

Lo nombramos "IngenieriaEconomica".



Para hacer uso del componente InputBox es necesario dirigirse al Explorador de soluciones, dar clic derecho a References, dentro de la etiqueta .NET seleccionar Micrososft.VisualBasic y aceptar.

Comenzamos colocando dos botones y una etiqueta. En el código del botón Quitar colocamos:

Environment.Exit(0); 

Dentro del botón Calcular colocamos:

double vp=0.0,vf=0.0,i=0.0;

int n=0;

try{

    vp=double.Parse(Microsoft.VisualBasic.Interaction.InputBox("Introduce monto inicial"));

    i=double.Parse(Microsoft.VisualBasic.Interaction.InputBox("Introduce tasa de interés"));

    n= int.Parse(Microsoft.VisualBasic.Interaction.InputBox("Introduce plazo"));

   if(n>0 && i>0 && vp>0){

        vf=vp*Math.Pow(1+i/100,n);

}else{

MessageBox.Show("no debe haber valores menores a cero");

}

label1.Text= "el valor o suma total generada es de $ "+vf;

}catch(Exception ex){

MessageBox.Show("Error: "+ex.Message);

}



Resultado: 

Listo

Groovy ... en ejemplos no. 4

Herencia
Al definir clases esperamos que estas cumplan todos los  requisitos necesarios, ni más ni menos. Si creamos una clase llamada Imagen, esta debe tener atributos que la identifiquen: nombre, tamaño, y url.

class Imagen{
     String nombre
     String tamanyo
     String url
}

Ahora una clase llamada TestImage con método main.

class TestImage{
     static main(args){
      def imagen=new Imagen(nombre:"Groovy.jpg",tamanyo:"45kb",url:"http://misimagenes.com.mx")  
   }

  //también podría haber sido así
  def imagen=new Imagen()
   imagen.with{
nombre="Groovy.jpg" 
tamanyo="45kb" 
url="http://misimagenes.com.mx"
   }

}

Al parecer no existe problema alguno, esta clase cumple su objetivo. Ahora ¿qué pasaría si necesitaramos agregarle alguna 'funcionalidad' extra? para ello usaremos la herencia.

Vamos a crear:

• Una clase base (o padre) llamada Heroe
• Dos clases hijas llamadas Superman y Batman 
• Dos interfaces llamadas Superpoderes y Habilidades
• Una clase llamada TestHeroe

//clase base
class Heroe{}
//clase hija hereda de clase padre
class SuperHeroe extends Heroe{}
//hace uso de los métodos de la interface Superpoderes
class Superman extends SuperHeroe implements Superpoderes{
    @Override
    public void vuelo(){
        println "Superman vuela"
    }

    @Override
    public void velocidad(){
        println "Superman corre a gran velocidad"
    }

    @Override
    public void fuerza(){
        println "Superman posee gran fuerza"
    }
}

//hace uso de la interface Habilidades
class Batman extends SuperHeroe implements Habilidades{
    @Override
    public void karate(){
        println "Batman sabe karate"
    }
}

interface Superpoderes{
    public abstract void vuelo()
    public abstract void velocidad()
    public abstract void fuerza()
}

interface Habilidades{
    public abstract void karate()
}

class TestHeroe{
    static main(args) {
        Superman superman=new Superman()
        Batman batman=new Batman()

        superman.vuelo()
        superman.velocidad()
        superman.fuerza()

        batman.karate()
    }
}

Salida:
Superman vuela
Superman corre a gran velocidad
Superman posee gran fuerza
Batman sabe karate
 
Ejecutamos: groovy TestHeroe.groovy

Código:http://www.pasteall.org/53722/groovy