jueves, 19 de mayo de 2011
Ligas a Youtube
Programacion orientada a objetos --> http://www.youtube.com/watch?v=NfG67dhk86M
Proyecto Final (Resumen)
Nuestro proyecto se puede distribuir mediant
e una empresa, es decir, que la agenda podría estar conectada a una red interna en la empresa, y ya conectada a la base de datos para guardar los registros, que el personal pueda acceder a sus contactos y también
poder comunicarse con ellos mediante la agendaInterfaz grafica:
Nuestra interfaz gráfica cuenta con dos ventanas, la primera que nos aparece es para acceder a la agenda, es una ventana en donde tenemos que introducir nuestro nombre de usuario y nuestra contraseña.Pruebas unitarias: Quisimos implementar pruebas unitarias en nuestro
proyecto ya que presenta varios modulos, por decir un area para modificar,
otra para guardar, salir, etc. y teniamos que verificar que cada unamiércoles, 18 de mayo de 2011
POO (session 11)
Nuestro proyecto se puede distribuir mediante una empresa, es decir, que la agenda podría estar conectada a una red interna en la empresa, y ya conectada a la base de datos para guardar los registros, que el personal pueda acceder a sus contactos y también poder comunicarse con ellos mediante la agenda, o poder hacer otro tip
o de cosas como mandarse mensajes entre ellos, mails, etc. Pensamos en muchas formas de darle esta distribución al proyecto, pero esta fue la que mejor nos llamo la atención.
lunes, 16 de mayo de 2011
TALLER POO
Los sistemas distribuidos necesitan un software distinto al de los sistemas centralizados. Los S. O. para sistemas distribuidos han tenido importantes desarrollos pero todavía existe un largo camino por recorrer.
Ventajas de los sistemas distribuidos con respecto de los centralizados.
Economía: es la razón número uno de la tendencia hacia los sistemas distribuidos ya que estos sistemas tienen en potencia una proporción precio/desempeño mucho mejor que la de un sistema centralizado.
Velocidad: un sistema distribuido puede tener mayor poder de cómputo que una mainframe.
Distribución inherente: otra razón para la construcción de un sistema distribuido es que ciertas aplicaciones son distribuidas en forma inherente; es decir, algunas aplicaciones utilizan máquinas que están separadas a cierta distancia.
Confiabilidad: un sistema distribuido ofrece mayor confiabilidad: al distribuir la carga de trabajo en muchas máquinas, la falla de un circuito descompondrá a lo más una máquina y el resto seguirá intacto.
Crecimiento por incrementos: si se necesita añadir poder de cómputo a la compañía, con un sistema distribuido, podrían añadirse sólo más procesadores al sistema, lo que permite un desarrollo gradual conforme surjan las necesidades.
Software: No hay mucha experiencia en el diseño, implantación y uso del software distribuido, además existe poco software para los sistemas distribuidos en la actualidad.
Redes: Una vez que el sistema llega a depender de la red, la pérdida o saturación de ésta puede negar algunas de las ventajas que el sistema distribuido debía conseguir.
Seguridad: si las personas pueden tener acceso a los datos en todo el sistema, entonces también pueden tener acceso a datos con los que no tienen nada que ver.
Taller POO (Interfaz Grafica)
domingo, 8 de mayo de 2011
POO (session 10)
Nuestra interfaz gráfica cuenta con dos ventanas, la primera que nos aparece es para acceder a la agenda, es una ventana en donde tenemos que introducir nuestro nombre de usuario y nuestra contraseña. Utilizamos los botones para que el usuario acepte que quiera ingresar a la agenda, y el otro de cancelar, para omitir todo.
Como vemos en la imagen de arriba, se puede apreciar dos botones, que el primero nos muestra la barra en donde debemos de escribir nuestro nombre de usuario y abajo la contraseña, después de presionar la tecla aceptar se nos aparecerá la ventana de nuestra agenda. En esta ventana es donde agregaremos, modificaremos, eliminaremos, guardemos y también podamos buscar a algún contacto en especifico. Nuestro primer menú es el de los “Datos del contacto” en donde tenemos que introducir varios datos como el nombre, dirección, teléfono, email y el sexo. Hay que destacar que el id no lo podemos introducir, ya que automáticamente se le agrega a cada contacto que agreguemos.
Otra cosa importante es que hicimos que estén inactivos los campos de texto, ya que queríamos que al momento de presionar el botón de nuevo (icono azul) se pueda habilitar estos campos, para después introducir los datos. Después de esto sigue el menú de botones, que contamos con 5 botones, el primero es para agregar un nuevo contacto, después tenemos para modificar un contacto seleccionado en la tabla que se muestra en la parte de abajo. Después de esto tenemos el botón de eliminar (rojo) en donde igual que al modificar, primero tendremos que seleccionar un contacto de la tabla y después seleccionar el botón de eliminar, se nos preguntara si realmente deseamos eliminar ese contacto. Después tenemos el botón de guardar, ya que hemos activado los campos de texto e introducir todos los datos, debemos de oprimir este botón para que automáticamente se guarde en nuestra base de datos. Al final del menú tenemos el botón de salir.
Extra POO
Taller de POO 8 (Demo parcial)
En este post les mostrare las funcionalidades que ahorita cuenta mi proyecto de la agenda personal, cuenta con los botones basicos como nuevo, modificar, salir, guardar y quitar. Aun me falta agregar varios eventos a varios botones, pero les mostrare como puedo agregar y quitar un contacto.
POO (session 9)
Aquí aparece la parte del código, es corto, y además fácil, pero muy eficiente, le dimos la instrucción de que primero apareciera la ventana del login, después de esto al introducir el usuario y contraseña nos mandara directamente a la página 2, a la otra ventana que tenemos hecha.
Excepciones: dentro de las excepciones en nuestro proyecto se encuentran varias, ya que las use más que nada en los botones que use en la interfaz. Ahora les mostrare una parte de mi código en donde utiliza el bloque try-catch, lo utilice en la interfaz gráfica, en el botón eliminar, ya que nos pediría la confirmación si realmente queremos eliminar un contacto y aparte para mandar la información a la base de datos de querer eliminarlo, hicimos lo mismo para la función de modificar.
jueves, 17 de marzo de 2011
POO (sesion 8)
- Patrones creacionales
- Patrones estructurales
- Patrones de comportamiento
- Command: Este patrón permite solicitar una operación a un objeto sin conocer realmente el contenido de esta operación, ni el receptor real de la misma. Para ello se encapsula la petición como un objeto, con lo que además se facilita la parametrización de los métodos
- Mediator: Cuando muchos objetos interactúan con otros objetos, se puede formar una estructura muy compleja, con objetos con muchas conexiones con otros objetos. En un caso extremo cada objeto puede conocer a todos los demás objetos. Para evitar esto el patrón Mediator encapsula el comportamiento de todo un conjunto de objetos en un solo objeto.
- Un conjunto grande de objetos se comunica de una forma bien definida, pero compleja.
- Reutilizar un objeto se hace difícil por que se relaciona con muchos objetos.
- El comportamiento de muchos objetos que esta distribuido entre varias clases, puede resumirse en una o variaspor subclasificación.
- Antipatrones de gestión
- Antipatrones de gestión de proyectos
- Antipatrones generales de diseño de software
- Antipatrones de diseño orientado a objetos
- Antipatrones de programación
- Antipatrones metodológicos
- Antipatrones de gestión de la configuración
martes, 15 de marzo de 2011
jueves, 24 de febrero de 2011
miércoles, 16 de febrero de 2011
Documentacion en doxygen
martes, 15 de febrero de 2011
Avance de clases en el proyecto final
En este avance identificamos las clases que usaremos
mientras para el proyecto, en esta clase llamada Usuarios
es donde se registraran obviamente las personas que agreguemos, cuenta
con una "id", "nombre", "direccion", "telefono", "email" y "sexo"
-------------------------------------------------------------
public class Contacto {
private Long id;
private String nombre;
private String direccion;
private String telefono;
private String email;
private String sexo;
public String getDireccion() {
return direccion;
}
public void setDireccion(String direccion) {
this.direccion = direccion;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public String getSexo() {
return sexo;
}
public void setSexo(String sexo) {
this.sexo = sexo;
}
public String getTelefono() {
return telefono;
}
public void setTelefono(String telefono) {
this.telefono = telefono;
}
}
-------------------------------------------------------------
En esta clase usaremos las Citas programadas, que
contaran con tambien un "id", "el nombre del contacto",
"fecha", "hora" y "evento".
public class Cita { int id; Contacto contacto; String direccion; String fecha; String hora; String evento; public Cita() { } public String getevento() { return evento; } public void setevento(String evento) { this.evento = evento; } public Contacto getContacto() { return contacto; } public void setContacto(Contacto contacto) { this.contacto = contacto; } public String getFecha() { return fecha; } public void setFecha(String fecha) { this.fecha = fecha; } public String getHora() { return hora; } public void setHora(String hora) { this.hora = hora; } public int getId() { return id; } public void setId(int id) { this.id = id; } public String getDireccion() { return lugar; } public void setDireccion(String direccion) { this.direccion = direccion; } }
------------------------------------------------------------
domingo, 6 de febrero de 2011
Taller de programacion orientada a objetos
Este programa que intente realizar es sencillo, ya que nos muestra el ID y el saldo de un cliente, este programa tiene 3 clases: Principal, Cliente y Cuenta.
--------------------------------------------------------------------------------------------------------------------------------------
en la clase Principal, le damos la instruccion que muestre el valor y el sueldo del cliente 1 (c1) y nos lo muestre en la pantalla, aqui le asignamos un numero de cliente y numero de cuenta que en la siguiente clase la declaramos privados
--------------------------------------------------------------------------------------------------------------------------------------
public class Principal {
public static void main (String[] args) {
Cliente c1 = new Cliente("1453478","Alejandro");
Cuenta cuenta1 = new Cuenta(c1,"001",25000);
System.out.print("Nombre:" + cuenta1.getCliente().getNombre());
System.out.println("Saldo:" + cuenta1.getSaldo());
}
}
--------------------------------------------------------------------------------------------------------------------------------------
en esta clase Cliente le damos las instrucciones para que se le asigne el nombre del id y del nombre, dandole atributos privados.
public class Cliente {
private String id;
private String nombre;
public Cliente(String id,String nombre) {
this.id=id;
this.nombre=nombre;
}
public String getId(){
return id;
}
public String getNombre(){
return nombre;
}
}
--------------------------------------------------------------------------------------------------------------------------------------
en la ultima clase que es Cuenta, es casi lo mismo que la clase anterior, que es para asignarle el numero de cuenta que es privado.
public class Cuenta {
private Cliente cliente;
private String numCuenta;
private double saldo;
public Cuenta(Cliente cliente,String numCuenta,double saldo){
this.cliente=cliente;
this.numCuenta=numCuenta;
this.saldo=saldo;
}
public Cliente getCliente() {
return cliente;
}
public String getNumCuenta() {
return numCuenta;
}
public double getSaldo(){
return saldo;
}
}
lunes, 31 de enero de 2011
Crisis del Software
- En 1962 se publicó el primer algoritmo para búsquedas binarias
- C.Böhm y G. Jacopini publicaron en 1966 el documento que creaba una fundación para la eliminación de "GoTo" y la creación de la programación estructurada.
- En 1968 los programadores se debatían entre el uso de la sentencia GoTo, y la nueva idea de programación estructurada; ese era el caldo de cultivo en el que Edsger Dijkstra escribió su famosa carta "GoTo Statement Considered Harmful" en 1968.
Por último, las aplicaciones de hoy en día son programas muy complejos, inabordables por una sola persona. En sus comienzos se valoró como causa también la inmadurez de la ingeniería de software, aunque todavía hoy en día no es posible realizar estimaciones precisas del coste y tiempo que necesitará un proyecto de software.
Englobó a una serie de sucesos que se venían observando en los proyectos de desarrollo de software:
- Los proyectos no terminaban en plazo.
- Los proyectos no se ajustaban al presupuesto inicial.
- Baja calidad del software generado.
- Software que no cumplía las especificaciones.
- Codigo inmantenible que dificultaba la gestión y evolución del proyecto.
Proyecto final
- jdk java development kit
- Linux
- emacs para escribir el codigo
- Mysql para la base de datos
- Android para dispositivos moviles
lunes, 24 de enero de 2011
Clase: Taller de programacion orientada a objetos
Las herramientas que utilizare para el avance del curso sera Python, ya que se me hace un lenguaje sencillo pero potente. Ubuntu por defecto ya cuenta con varios lenguajes de programación, por lo que ya cuenta con en lenguaje Python.
Se trata de un lenguaje de programación multiparadigma ya que soporta orientación a objetos, programación imperativa y, en menor medida, programación multifuncional. Es un interpretado, usa tipado dinámico, es fuertemente tipado y es multiplataforma.
Este es un programa sencillo que hice en python, que muestra las poblaciones de 4 ciudades en total
--------------------------------------------------------------------------------------------------------------------------------------
#le damos nombre a la clase u objeto, aqui solo pongo un objeto
class Ciudad:
#despues de esto con la instruccion def_init_ le damos valores a los atributos, en este caso ciudad y habitantes, y las instrucciones para los metodos
def __init__(self, ciudad, habitantes):
self.nombrec = ciudad
self.habitantes = habitantes
def getNombre(self):
return self.nombrec
def getNumeroHabitantes(self):
return self.habitantes
def main():
#aqui ponemos las ciudades y el numero de habitantes que aparezcan en la pantalla
ciudad1 = Ciudad("Madrid", 170.187)
ciudad2 = Ciudad("Cataluna", 143.933)
ciudad3 = Ciudad("Monterrey", 1.130960)
ciudad4 = Ciudad("Paris", 2.193031)
#mandamos a imprimir los numeros de habitantes con sus respectivas ciudades
print ciudad1.getNombre()
print ciudad1.getNumeroHabitantes()
print ciudad2.getNombre()
print ciudad2.getNumeroHabitantes()
print ciudad3.getNombre()
print ciudad3.getNumeroHabitantes()
print ciudad4.getNombre()
print ciudad4.getNumeroHabitantes()
main()
#fin del programa #alejandro josafat-1453478
--------------------------------------------------------------------------------------------------------------------------------------
me base en los métodos y atributos de la siguiente pagina
http://www.linuxhispano.net/2009/10/29/metodos-estaticos-en-python/
Dra. Sara no pude como poner el syntax highlight espero y poder preguntarle para corregirlo